Add tests

microsoft · Nov 29, 2019 · 62a1d57 · 62a1d57
1 parent 5bc3b96
commit 62a1d57
Show file tree

Hide file tree

Showing 12 changed files with 204 additions and 8 deletions.
diff --git a/tests/baselines/reference/asyncFunctionReturnType.js b/tests/baselines/reference/asyncFunctionReturnType.js
@@ -74,6 +74,13 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
 async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<Awaited<TObj[K]>> {
     return Promise.resolve<TObj[K]>(obj[key]);
 }
+
+// #27711
+
+async function fGeneric<T>(x: T) {
+    return x;
+}
+const expected: Promise<number> = fGeneric(undefined as Promise<number>);
 
 
 //// [asyncFunctionReturnType.js]
@@ -173,3 +180,10 @@ function fGenericIndexedTypeForExplicitPromiseOfKProp(obj, key) {
         return Promise.resolve(obj[key]);
     });
 }
+// #27711
+function fGeneric(x) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return x;
+    });
+}
+const expected = fGeneric(undefined);
diff --git a/tests/baselines/reference/asyncFunctionReturnType.symbols b/tests/baselines/reference/asyncFunctionReturnType.symbols
@@ -289,3 +289,21 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 72, 110))
 }
 
+// #27711
+
+async function fGeneric<T>(x: T) {
+>fGeneric : Symbol(fGeneric, Decl(asyncFunctionReturnType.ts, 74, 1))
+>T : Symbol(T, Decl(asyncFunctionReturnType.ts, 78, 24))
+>x : Symbol(x, Decl(asyncFunctionReturnType.ts, 78, 27))
+>T : Symbol(T, Decl(asyncFunctionReturnType.ts, 78, 24))
+
+    return x;
+>x : Symbol(x, Decl(asyncFunctionReturnType.ts, 78, 27))
+}
+const expected: Promise<number> = fGeneric(undefined as Promise<number>);
+>expected : Symbol(expected, Decl(asyncFunctionReturnType.ts, 81, 5))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>fGeneric : Symbol(fGeneric, Decl(asyncFunctionReturnType.ts, 74, 1))
+>undefined : Symbol(undefined)
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+
diff --git a/tests/baselines/reference/asyncFunctionReturnType.types b/tests/baselines/reference/asyncFunctionReturnType.types
@@ -221,3 +221,19 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
 >key : K
 }
 
+// #27711
+
+async function fGeneric<T>(x: T) {
+>fGeneric : <T>(x: T) => Promise<Awaited<T>>
+>x : T
+
+    return x;
+>x : T
+}
+const expected: Promise<number> = fGeneric(undefined as Promise<number>);
+>expected : Promise<number>
+>fGeneric(undefined as Promise<number>) : Promise<number>
+>fGeneric : <T>(x: T) => Promise<Awaited<T>>
+>undefined as Promise<number> : Promise<number>
+>undefined : undefined
+
diff --git a/tests/baselines/reference/correctOrderOfPromiseMethod.js b/tests/baselines/reference/correctOrderOfPromiseMethod.js
@@ -15,7 +15,7 @@ async function countEverything(): Promise<number> {
     const [resultA, resultB] = await Promise.all([
         providerA(),
         providerB(),
-    ] as const);
+    ]);
 
     const dataA: A[] = resultA;
     const dataB: B[] = resultB;
@@ -24,6 +24,10 @@ async function countEverything(): Promise<number> {
     }
     return 0;
 }
+
+// #31179
+
+const expected: Promise<['a', 'b', 'c']> = Promise.all(undefined as readonly ['a', 'b', 'c']);
 
 
 //// [correctOrderOfPromiseMethod.js]
@@ -92,3 +96,5 @@ function countEverything() {
         });
     });
 }
+// #31179
+var expected = Promise.all(undefined);
diff --git a/tests/baselines/reference/correctOrderOfPromiseMethod.symbols b/tests/baselines/reference/correctOrderOfPromiseMethod.symbols
@@ -43,7 +43,7 @@ async function countEverything(): Promise<number> {
         providerB(),
 >providerB : Symbol(providerB, Decl(correctOrderOfPromiseMethod.ts, 11, 9))
 
-    ] as const);
+    ]);
 
     const dataA: A[] = resultA;
 >dataA : Symbol(dataA, Decl(correctOrderOfPromiseMethod.ts, 18, 9))
@@ -70,3 +70,13 @@ async function countEverything(): Promise<number> {
     return 0;
 }
 
+// #31179
+
+const expected: Promise<['a', 'b', 'c']> = Promise.all(undefined as readonly ['a', 'b', 'c']);
+>expected : Symbol(expected, Decl(correctOrderOfPromiseMethod.ts, 28, 5))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>undefined : Symbol(undefined)
+
diff --git a/tests/baselines/reference/correctOrderOfPromiseMethod.types b/tests/baselines/reference/correctOrderOfPromiseMethod.types
@@ -28,13 +28,12 @@ async function countEverything(): Promise<number> {
     const [resultA, resultB] = await Promise.all([
 >resultA : A[]
 >resultB : B[]
->await Promise.all([        providerA(),        providerB(),    ] as const) : [A[], B[]]
->Promise.all([        providerA(),        providerB(),    ] as const) : Promise<[A[], B[]]>
+>await Promise.all([        providerA(),        providerB(),    ]) : [A[], B[]]
+>Promise.all([        providerA(),        providerB(),    ]) : Promise<[A[], B[]]>
 >Promise.all : { <TAll>(values: Iterable<TAll>): Promise<Awaited<TAll>[]>; <T extends readonly any[]>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>; }
 >Promise : PromiseConstructor
 >all : { <TAll>(values: Iterable<TAll>): Promise<Awaited<TAll>[]>; <T extends readonly any[]>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>; }
->[        providerA(),        providerB(),    ] as const : readonly [Promise<A[]>, Promise<B[]>]
->[        providerA(),        providerB(),    ] : readonly [Promise<A[]>, Promise<B[]>]
+>[        providerA(),        providerB(),    ] : [Promise<A[]>, Promise<B[]>]
 
         providerA(),
 >providerA() : Promise<A[]>
@@ -44,7 +43,7 @@ async function countEverything(): Promise<number> {
 >providerB() : Promise<B[]>
 >providerB : () => Promise<B[]>
 
-    ] as const);
+    ]);
 
     const dataA: A[] = resultA;
 >dataA : A[]
@@ -72,3 +71,14 @@ async function countEverything(): Promise<number> {
 >0 : 0
 }
 
+// #31179
+
+const expected: Promise<['a', 'b', 'c']> = Promise.all(undefined as readonly ['a', 'b', 'c']);
+>expected : Promise<["a", "b", "c"]>
+>Promise.all(undefined as readonly ['a', 'b', 'c']) : Promise<["a", "b", "c"]>
+>Promise.all : { <TAll>(values: Iterable<TAll>): Promise<Awaited<TAll>[]>; <T extends readonly any[]>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>; }
+>Promise : PromiseConstructor
+>all : { <TAll>(values: Iterable<TAll>): Promise<Awaited<TAll>[]>; <T extends readonly any[]>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>; }
+>undefined as readonly ['a', 'b', 'c'] : readonly ["a", "b", "c"]
+>undefined : undefined
+
diff --git a/tests/baselines/reference/promiseType.js b/tests/baselines/reference/promiseType.js
@@ -217,6 +217,20 @@ const pc6 = p.then(() => Promise.reject("1"), () => {});
 const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
+
+const expected1: undefined = undefined as Awaited<undefined>;
+
+// #27711
+
+const expected2: Promise<number> = new Promise<Promise<number>>(() => {});
+
+// #28427
+
+Promise.all([undefined as Promise<number> | string]);
+
+Promise.resolve(undefined as Promise<number> | string);
+
+new Promise(undefined as (resolve: (value: Promise<number> | string) => void) => void);
 
 
 //// [promiseType.js]
@@ -440,3 +454,10 @@ const pc6 = p.then(() => Promise.reject("1"), () => { });
 const pc7 = p.then(() => Promise.reject("1"), () => { throw 1; });
 const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
+const expected1 = undefined;
+// #27711
+const expected2 = new Promise(() => { });
+// #28427
+Promise.all([undefined]);
+Promise.resolve(undefined);
+new Promise(undefined);
diff --git a/tests/baselines/reference/promiseType.symbols b/tests/baselines/reference/promiseType.symbols
@@ -1089,3 +1089,39 @@ const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --))
 
+const expected1: undefined = undefined as Awaited<undefined>;
+>expected1 : Symbol(expected1, Decl(promiseType.ts, 219, 5))
+>undefined : Symbol(undefined)
+>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --))
+
+// #27711
+
+const expected2: Promise<number> = new Promise<Promise<number>>(() => {});
+>expected2 : Symbol(expected2, Decl(promiseType.ts, 223, 5))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+
+// #28427
+
+Promise.all([undefined as Promise<number> | string]);
+>Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>undefined : Symbol(undefined)
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+
+Promise.resolve(undefined as Promise<number> | string);
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>undefined : Symbol(undefined)
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+
+new Promise(undefined as (resolve: (value: Promise<number> | string) => void) => void);
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>undefined : Symbol(undefined)
+>resolve : Symbol(resolve, Decl(promiseType.ts, 231, 26))
+>value : Symbol(value, Decl(promiseType.ts, 231, 36))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+
diff --git a/tests/baselines/reference/promiseType.types b/tests/baselines/reference/promiseType.types
@@ -1583,3 +1583,43 @@ const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >reject : <T = never>(reason?: any) => Promise<T>
 >1 : 1
 
+const expected1: undefined = undefined as Awaited<undefined>;
+>expected1 : undefined
+>undefined as Awaited<undefined> : undefined
+>undefined : undefined
+
+// #27711
+
+const expected2: Promise<number> = new Promise<Promise<number>>(() => {});
+>expected2 : Promise<number>
+>new Promise<Promise<number>>(() => {}) : Promise<number>
+>Promise : PromiseConstructor
+>() => {} : () => void
+
+// #28427
+
+Promise.all([undefined as Promise<number> | string]);
+>Promise.all([undefined as Promise<number> | string]) : Promise<(string | number)[]>
+>Promise.all : { <TAll>(values: Iterable<TAll>): Promise<Awaited<TAll>[]>; <T extends readonly any[]>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>; }
+>Promise : PromiseConstructor
+>all : { <TAll>(values: Iterable<TAll>): Promise<Awaited<TAll>[]>; <T extends readonly any[]>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>; }
+>[undefined as Promise<number> | string] : (string | Promise<number>)[]
+>undefined as Promise<number> | string : string | Promise<number>
+>undefined : undefined
+
+Promise.resolve(undefined as Promise<number> | string);
+>Promise.resolve(undefined as Promise<number> | string) : Promise<string | number>
+>Promise.resolve : { <T>(value: T): Promise<Awaited<T>>; (): Promise<void>; }
+>Promise : PromiseConstructor
+>resolve : { <T>(value: T): Promise<Awaited<T>>; (): Promise<void>; }
+>undefined as Promise<number> | string : string | Promise<number>
+>undefined : undefined
+
+new Promise(undefined as (resolve: (value: Promise<number> | string) => void) => void);
+>new Promise(undefined as (resolve: (value: Promise<number> | string) => void) => void) : Promise<string | number>
+>Promise : PromiseConstructor
+>undefined as (resolve: (value: Promise<number> | string) => void) => void : (resolve: (value: string | Promise<number>) => void) => void
+>undefined : undefined
+>resolve : (value: string | Promise<number>) => void
+>value : string | Promise<number>
+
diff --git a/tests/cases/compiler/asyncFunctionReturnType.ts b/tests/cases/compiler/asyncFunctionReturnType.ts
@@ -74,3 +74,10 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
 async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<Awaited<TObj[K]>> {
     return Promise.resolve<TObj[K]>(obj[key]);
 }
+
+// #27711
+
+async function fGeneric<T>(x: T) {
+    return x;
+}
+const expected: Promise<number> = fGeneric(undefined as Promise<number>);
diff --git a/tests/cases/compiler/correctOrderOfPromiseMethod.ts b/tests/cases/compiler/correctOrderOfPromiseMethod.ts
@@ -17,7 +17,7 @@ async function countEverything(): Promise<number> {
     const [resultA, resultB] = await Promise.all([
         providerA(),
         providerB(),
-    ] as const);
+    ]);
 
     const dataA: A[] = resultA;
     const dataB: B[] = resultB;
@@ -26,3 +26,7 @@ async function countEverything(): Promise<number> {
     }
     return 0;
 }
+
+// #31179
+
+const expected: Promise<['a', 'b', 'c']> = Promise.all(undefined as readonly ['a', 'b', 'c']);
diff --git a/tests/cases/compiler/promiseType.ts b/tests/cases/compiler/promiseType.ts
@@ -217,3 +217,17 @@ const pc6 = p.then(() => Promise.reject("1"), () => {});
 const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
+
+const expected1: undefined = undefined as Awaited<undefined>;
+
+// #27711
+
+const expected2: Promise<number> = new Promise<Promise<number>>(() => {});
+
+// #28427
+
+Promise.all([undefined as Promise<number> | string]);
+
+Promise.resolve(undefined as Promise<number> | string);
+
+new Promise(undefined as (resolve: (value: Promise<number> | string) => void) => void);