From 040c1216ff2e9398f648e5475533f1fa80d7aca1 Mon Sep 17 00:00:00 2001
From: Jack Bates <jack@nottheoilrig.com>
Date: Tue, 2 Aug 2022 10:39:50 -0700
Subject: [PATCH] Better typings for Promise.resolve(), like #31117 (#33074)

* Better typings for Promise.resolve(), like #31117

* Add tests

* Update to Awaited<T>

* Fix issue with Awaited affecting jQuery, additional tests

Co-authored-by: Ron Buckton <ron.buckton@microsoft.com>
---
 src/lib/es2015.promise.d.ts                   |  13 +-
 src/lib/es5.d.ts                              |   4 +-
 .../asyncArrowFunction11_es5.symbols          |   4 +-
 .../reference/asyncArrowFunction11_es5.types  |   4 +-
 .../asyncArrowFunction9_es2017.errors.txt     |   2 +-
 .../asyncArrowFunction9_es5.errors.txt        |   2 +-
 .../asyncArrowFunction9_es6.errors.txt        |   2 +-
 .../reference/asyncFunctionReturnType.symbols |  40 +-
 .../reference/asyncFunctionReturnType.types   |  48 +-
 .../awaitCallExpressionInSyncFunction.symbols |   4 +-
 .../awaitCallExpressionInSyncFunction.types   |   4 +-
 .../baselines/reference/awaitedTypeJQuery.js  | 129 +++
 .../reference/awaitedTypeJQuery.symbols       | 793 ++++++++++++++++++
 .../reference/awaitedTypeJQuery.types         | 224 +++++
 .../classStaticBlock23(target=es2022).symbols |   4 +-
 .../classStaticBlock23(target=es2022).types   |   4 +-
 .../classStaticBlock23(target=esnext).symbols |   4 +-
 .../classStaticBlock23(target=esnext).types   |   4 +-
 ...es5-asyncFunctionLongObjectLiteral.symbols |  60 +-
 .../es5-asyncFunctionLongObjectLiteral.types  |  60 +-
 .../exportDefaultAsyncFunction2.symbols       |   4 +-
 .../exportDefaultAsyncFunction2.types         |   4 +-
 .../generatorReturnContextualType.symbols     |   8 +-
 .../generatorReturnContextualType.types       |   8 +-
 .../genericFunctionInference1.symbols         |   4 +-
 .../reference/genericFunctionInference1.types |   4 +-
 ...ferFromGenericFunctionReturnTypes3.symbols |   4 +-
 ...inferFromGenericFunctionReturnTypes3.types |   4 +-
 .../instantiateContextualTypes.symbols        |  12 +-
 .../instantiateContextualTypes.types          |  12 +-
 ...ntersectionWithConflictingPrivates.symbols |   4 +-
 .../intersectionWithConflictingPrivates.types |   4 +-
 ...DeclarationsJSDocRedirectedLookups.symbols |   4 +-
 ...jsDeclarationsJSDocRedirectedLookups.types |   4 +-
 .../jsFileCompilationAwaitModifier.symbols    |   8 +-
 .../jsFileCompilationAwaitModifier.types      |   8 +-
 ...jsdocArrayObjectPromiseImplicitAny.symbols |   8 +-
 .../jsdocArrayObjectPromiseImplicitAny.types  |   8 +-
 ...docArrayObjectPromiseNoImplicitAny.symbols |   8 +-
 ...jsdocArrayObjectPromiseNoImplicitAny.types |   8 +-
 .../noImplicitReturnsInAsync1.symbols         |   4 +-
 .../reference/noImplicitReturnsInAsync1.types |   4 +-
 .../reference/privateNameMethodAsync.symbols  |   8 +-
 .../reference/privateNameMethodAsync.types    |   8 +-
 .../privateNameStaticMethodAsync.symbols      |   8 +-
 .../privateNameStaticMethodAsync.types        |   8 +-
 tests/baselines/reference/promiseType.js      |  12 +-
 tests/baselines/reference/promiseType.symbols | 129 ++-
 tests/baselines/reference/promiseType.types   | 128 ++-
 .../reference/promiseTypeStrictNull.symbols   |  88 +-
 .../reference/promiseTypeStrictNull.types     |  88 +-
 .../promiseVoidErrorCallback.symbols          |   4 +-
 .../reference/promiseVoidErrorCallback.types  |   4 +-
 ...ait.1(module=es2022,target=es2015).symbols |   4 +-
 ...Await.1(module=es2022,target=es2015).types |   4 +-
 ...ait.1(module=es2022,target=es2017).symbols |   4 +-
 ...Await.1(module=es2022,target=es2017).types |   4 +-
 ...ait.1(module=esnext,target=es2015).symbols |   4 +-
 ...Await.1(module=esnext,target=es2015).types |   4 +-
 ...ait.1(module=esnext,target=es2017).symbols |   4 +-
 ...Await.1(module=esnext,target=es2017).types |   4 +-
 ...ait.1(module=system,target=es2015).symbols |   4 +-
 ...Await.1(module=system,target=es2015).types |   4 +-
 ...ait.1(module=system,target=es2017).symbols |   4 +-
 ...Await.1(module=system,target=es2017).types |   4 +-
 ...LevelAwaitNonModule(module=es2022).symbols |   4 +-
 ...opLevelAwaitNonModule(module=es2022).types |   4 +-
 ...LevelAwaitNonModule(module=esnext).symbols |   4 +-
 ...opLevelAwaitNonModule(module=esnext).types |   4 +-
 .../transformNestedGeneratorsWithTry.symbols  |   4 +-
 .../transformNestedGeneratorsWithTry.types    |   4 +-
 .../types.asyncGenerators.es2018.1.symbols    |  64 +-
 .../types.asyncGenerators.es2018.1.types      |  64 +-
 .../types.asyncGenerators.es2018.2.symbols    |   4 +-
 .../types.asyncGenerators.es2018.2.types      |   4 +-
 .../unionAndIntersectionInference1.symbols    |   4 +-
 .../unionAndIntersectionInference1.types      |   4 +-
 .../baselines/reference/uniqueSymbols.symbols |   4 +-
 tests/baselines/reference/uniqueSymbols.types |   4 +-
 .../uniqueSymbolsDeclarations.symbols         |   4 +-
 .../reference/uniqueSymbolsDeclarations.types |   4 +-
 tests/baselines/reference/user/fp-ts.log      |  12 +
 tests/cases/compiler/awaitedTypeJQuery.ts     | 125 +++
 tests/cases/compiler/promiseType.ts           |   6 +
 84 files changed, 1895 insertions(+), 510 deletions(-)
 create mode 100644 tests/baselines/reference/awaitedTypeJQuery.js
 create mode 100644 tests/baselines/reference/awaitedTypeJQuery.symbols
 create mode 100644 tests/baselines/reference/awaitedTypeJQuery.types
 create mode 100644 tests/baselines/reference/user/fp-ts.log
 create mode 100644 tests/cases/compiler/awaitedTypeJQuery.ts

diff --git a/src/lib/es2015.promise.d.ts b/src/lib/es2015.promise.d.ts
index ac8f36de4b911..68b476d8c2fc6 100644
--- a/src/lib/es2015.promise.d.ts
+++ b/src/lib/es2015.promise.d.ts
@@ -21,7 +21,7 @@ interface PromiseConstructor {
     all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;
 
     // see: lib.es2015.iterable.d.ts
-    // all<T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>;
+    // all<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -32,7 +32,7 @@ interface PromiseConstructor {
     race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
 
     // see: lib.es2015.iterable.d.ts
-    // race<T>(values: Iterable<T>): Promise<T extends PromiseLike<infer U> ? U : T>;
+    // race<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
 
     /**
      * Creates a new rejected promise for the provided reason.
@@ -46,13 +46,18 @@ interface PromiseConstructor {
      * @returns A resolved promise.
      */
     resolve(): Promise<void>;
-
     /**
      * Creates a new resolved promise for the provided value.
      * @param value A promise.
      * @returns A promise whose internal state matches the provided promise.
      */
-    resolve<T>(value: T | PromiseLike<T>): Promise<T>;
+    resolve<T>(value: T): Promise<Awaited<T>>;
+    /**
+     * Creates a new resolved promise for the provided value.
+     * @param value A promise.
+     * @returns A promise whose internal state matches the provided promise.
+     */
+    resolve<T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
 }
 
 declare var Promise: PromiseConstructor;
diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
index b062a920c37c3..934a5cdde69ee 100644
--- a/src/lib/es5.d.ts
+++ b/src/lib/es5.d.ts
@@ -1512,8 +1512,8 @@ interface Promise<T> {
  */
 type Awaited<T> =
     T extends null | undefined ? T : // special case for `null | undefined` when not in `--strictNullChecks` mode
-        T extends object & { then(onfulfilled: infer F): any } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
-            F extends ((value: infer V, ...args: any) => any) ? // if the argument to `then` is callable, extracts the first argument
+        T extends object & { then(onfulfilled: infer F, ...args: infer _): any } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
+            F extends ((value: infer V, ...args: infer _) => any) ? // if the argument to `then` is callable, extracts the first argument
                 Awaited<V> : // recursively unwrap the value
                 never : // the argument to `then` was not callable
         T; // non-object or non-thenable
diff --git a/tests/baselines/reference/asyncArrowFunction11_es5.symbols b/tests/baselines/reference/asyncArrowFunction11_es5.symbols
index aff484d592795..b78c43d12eb52 100644
--- a/tests/baselines/reference/asyncArrowFunction11_es5.symbols
+++ b/tests/baselines/reference/asyncArrowFunction11_es5.symbols
@@ -8,9 +8,9 @@ class A {
 >args : Symbol(args, Decl(asyncArrowFunction11_es5.ts, 2, 15))
 
         await Promise.resolve();
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         const obj = { ["a"]: () => this }; // computed property name after `await` triggers case
 >obj : Symbol(obj, Decl(asyncArrowFunction11_es5.ts, 4, 13))
diff --git a/tests/baselines/reference/asyncArrowFunction11_es5.types b/tests/baselines/reference/asyncArrowFunction11_es5.types
index ac144c61b8b87..e3860195a5fa4 100644
--- a/tests/baselines/reference/asyncArrowFunction11_es5.types
+++ b/tests/baselines/reference/asyncArrowFunction11_es5.types
@@ -11,9 +11,9 @@ class A {
         await Promise.resolve();
 >await Promise.resolve() : void
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 
         const obj = { ["a"]: () => this }; // computed property name after `await` triggers case
 >obj : { a: () => this; }
diff --git a/tests/baselines/reference/asyncArrowFunction9_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction9_es2017.errors.txt
index 7088e40bae2c0..a857ec7505cb0 100644
--- a/tests/baselines/reference/asyncArrowFunction9_es2017.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction9_es2017.errors.txt
@@ -16,7 +16,7 @@ tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction9_es20
 !!! error TS1005: ',' expected.
                                           ~~~~~~~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'any'.
-!!! related TS6203 /.ts/lib.es2015.promise.d.ts:78:13: 'Promise' was also declared here.
+!!! related TS6203 /.ts/lib.es2015.promise.d.ts:83:13: 'Promise' was also declared here.
                                                  ~
 !!! error TS1005: ',' expected.
                                                         ~~
diff --git a/tests/baselines/reference/asyncArrowFunction9_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction9_es5.errors.txt
index bd89949dbc1f8..77ffd050cd6ee 100644
--- a/tests/baselines/reference/asyncArrowFunction9_es5.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction9_es5.errors.txt
@@ -16,7 +16,7 @@ tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction9_es5.ts(
 !!! error TS1005: ',' expected.
                                           ~~~~~~~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'any'.
-!!! related TS6203 /.ts/lib.es2015.promise.d.ts:78:13: 'Promise' was also declared here.
+!!! related TS6203 /.ts/lib.es2015.promise.d.ts:83:13: 'Promise' was also declared here.
                                                  ~
 !!! error TS1005: ',' expected.
                                                         ~~
diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt
index 3335bebfa817c..aba7af02e7361 100644
--- a/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt
@@ -16,7 +16,7 @@ tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(
 !!! error TS1005: ',' expected.
                                           ~~~~~~~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'any'.
-!!! related TS6203 /.ts/lib.es2015.promise.d.ts:78:13: 'Promise' was also declared here.
+!!! related TS6203 /.ts/lib.es2015.promise.d.ts:83:13: 'Promise' was also declared here.
                                                  ~
 !!! error TS1005: ',' expected.
                                                         ~~
diff --git a/tests/baselines/reference/asyncFunctionReturnType.symbols b/tests/baselines/reference/asyncFunctionReturnType.symbols
index 25a7e944c6a7a..72fe3c9c2a974 100644
--- a/tests/baselines/reference/asyncFunctionReturnType.symbols
+++ b/tests/baselines/reference/asyncFunctionReturnType.symbols
@@ -46,9 +46,9 @@ async function fIndexedTypeForPromiseOfStringProp(obj: Obj): Promise<Obj["string
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve(obj.stringProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 20, 50))
 >stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
@@ -62,9 +62,9 @@ async function fIndexedTypeForExplicitPromiseOfStringProp(obj: Obj): Promise<Obj
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve<Obj["stringProp"]>(obj.stringProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 24, 58))
@@ -92,9 +92,9 @@ async function fIndexedTypeForPromiseOfAnyProp(obj: Obj): Promise<Obj["anyProp"]
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve(obj.anyProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 32, 47))
 >anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
@@ -108,9 +108,9 @@ async function fIndexedTypeForExplicitPromiseOfAnyProp(obj: Obj): Promise<Obj["a
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve<Obj["anyProp"]>(obj.anyProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 36, 55))
@@ -142,9 +142,9 @@ async function fGenericIndexedTypeForPromiseOfStringProp<TObj extends Obj>(obj:
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 44, 57))
 
     return Promise.resolve(obj.stringProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 44, 75))
 >stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
@@ -160,9 +160,9 @@ async function fGenericIndexedTypeForExplicitPromiseOfStringProp<TObj extends Ob
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 48, 65))
 
     return Promise.resolve<TObj["stringProp"]>(obj.stringProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 48, 65))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 48, 83))
@@ -194,9 +194,9 @@ async function fGenericIndexedTypeForPromiseOfAnyProp<TObj extends Obj>(obj: TOb
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 56, 54))
 
     return Promise.resolve(obj.anyProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 56, 72))
 >anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
@@ -212,9 +212,9 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 60, 62))
 
     return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 60, 62))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 60, 80))
@@ -255,9 +255,9 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 68, 69))
 
     return Promise.resolve(obj[key]);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 68, 92))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 68, 102))
 }
@@ -277,9 +277,9 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 72, 77))
 
     return Promise.resolve<TObj[K]>(obj[key]);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 72, 60))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 72, 77))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 72, 100))
diff --git a/tests/baselines/reference/asyncFunctionReturnType.types b/tests/baselines/reference/asyncFunctionReturnType.types
index 3c48607ce516c..46acb1daf5198 100644
--- a/tests/baselines/reference/asyncFunctionReturnType.types
+++ b/tests/baselines/reference/asyncFunctionReturnType.types
@@ -44,9 +44,9 @@ async function fIndexedTypeForPromiseOfStringProp(obj: Obj): Promise<Obj["string
 
     return Promise.resolve(obj.stringProp);
 >Promise.resolve(obj.stringProp) : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >obj.stringProp : string
 >obj : Obj
 >stringProp : string
@@ -58,9 +58,9 @@ async function fIndexedTypeForExplicitPromiseOfStringProp(obj: Obj): Promise<Obj
 
     return Promise.resolve<Obj["stringProp"]>(obj.stringProp);
 >Promise.resolve<Obj["stringProp"]>(obj.stringProp) : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >obj.stringProp : string
 >obj : Obj
 >stringProp : string
@@ -82,9 +82,9 @@ async function fIndexedTypeForPromiseOfAnyProp(obj: Obj): Promise<Obj["anyProp"]
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve(obj.anyProp) : Promise<any>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >obj.anyProp : any
 >obj : Obj
 >anyProp : any
@@ -96,9 +96,9 @@ async function fIndexedTypeForExplicitPromiseOfAnyProp(obj: Obj): Promise<Obj["a
 
     return Promise.resolve<Obj["anyProp"]>(obj.anyProp);
 >Promise.resolve<Obj["anyProp"]>(obj.anyProp) : Promise<any>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >obj.anyProp : any
 >obj : Obj
 >anyProp : any
@@ -120,9 +120,9 @@ async function fGenericIndexedTypeForPromiseOfStringProp<TObj extends Obj>(obj:
 
     return Promise.resolve(obj.stringProp);
 >Promise.resolve(obj.stringProp) : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >obj.stringProp : string
 >obj : TObj
 >stringProp : string
@@ -133,10 +133,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfStringProp<TObj extends Ob
 >obj : TObj
 
     return Promise.resolve<TObj["stringProp"]>(obj.stringProp);
->Promise.resolve<TObj["stringProp"]>(obj.stringProp) : Promise<TObj["stringProp"]>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve<TObj["stringProp"]>(obj.stringProp) : Promise<Awaited<TObj["stringProp"]>>
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >obj.stringProp : string
 >obj : TObj
 >stringProp : string
@@ -158,9 +158,9 @@ async function fGenericIndexedTypeForPromiseOfAnyProp<TObj extends Obj>(obj: TOb
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve(obj.anyProp) : Promise<any>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >obj.anyProp : any
 >obj : TObj
 >anyProp : any
@@ -171,10 +171,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
 >obj : TObj
 
     return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
->Promise.resolve<TObj["anyProp"]>(obj.anyProp) : Promise<TObj["anyProp"]>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve<TObj["anyProp"]>(obj.anyProp) : Promise<Awaited<TObj["anyProp"]>>
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >obj.anyProp : any
 >obj : TObj
 >anyProp : any
@@ -197,10 +197,10 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
 >key : K
 
     return Promise.resolve(obj[key]);
->Promise.resolve(obj[key]) : Promise<TObj[K]>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve(obj[key]) : Promise<Awaited<TObj[K]>>
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >obj[key] : TObj[K]
 >obj : TObj
 >key : K
@@ -212,10 +212,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
 >key : K
 
     return Promise.resolve<TObj[K]>(obj[key]);
->Promise.resolve<TObj[K]>(obj[key]) : Promise<TObj[K]>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve<TObj[K]>(obj[key]) : Promise<Awaited<TObj[K]>>
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >obj[key] : TObj[K]
 >obj : TObj
 >key : K
diff --git a/tests/baselines/reference/awaitCallExpressionInSyncFunction.symbols b/tests/baselines/reference/awaitCallExpressionInSyncFunction.symbols
index b41b6c2f67a0b..898725dce4b28 100644
--- a/tests/baselines/reference/awaitCallExpressionInSyncFunction.symbols
+++ b/tests/baselines/reference/awaitCallExpressionInSyncFunction.symbols
@@ -4,9 +4,9 @@ function foo() {
 
    const foo = await(Promise.resolve(1));
 >foo : Symbol(foo, Decl(awaitCallExpressionInSyncFunction.ts, 1, 8))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
    return foo;
 >foo : Symbol(foo, Decl(awaitCallExpressionInSyncFunction.ts, 1, 8))
diff --git a/tests/baselines/reference/awaitCallExpressionInSyncFunction.types b/tests/baselines/reference/awaitCallExpressionInSyncFunction.types
index d3aeb8a72368f..aa5b0a415a297 100644
--- a/tests/baselines/reference/awaitCallExpressionInSyncFunction.types
+++ b/tests/baselines/reference/awaitCallExpressionInSyncFunction.types
@@ -7,9 +7,9 @@ function foo() {
 >await(Promise.resolve(1)) : any
 >await : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
    return foo;
diff --git a/tests/baselines/reference/awaitedTypeJQuery.js b/tests/baselines/reference/awaitedTypeJQuery.js
new file mode 100644
index 0000000000000..5963a2d93804c
--- /dev/null
+++ b/tests/baselines/reference/awaitedTypeJQuery.js
@@ -0,0 +1,129 @@
+//// [awaitedTypeJQuery.ts]
+/// <reference lib="dom" />
+
+interface Thenable<T> extends PromiseLike<T> { }
+
+// JQuery's Promise type
+interface PromiseBase<TR, TJ, TN,
+    UR, UJ, UN,
+    VR, VJ, VN,
+    SR, SJ, SN> {
+    then<ARD = never, AJD = never, AND = never,
+        BRD = never, BJD = never, BND = never,
+        CRD = never, CJD = never, CND = never,
+        RRD = never, RJD = never, RND = never,
+        ARF = never, AJF = never, ANF = never,
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never,
+        ARP = never, AJP = never, ANP = never,
+        BRP = never, BJP = never, BNP = never,
+        CRP = never, CJP = never, CNP = never,
+        RRP = never, RJP = never, RNP = never>(
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                BRD, BJD, BND,
+                CRD, CJD, CND,
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                BRP, BJP, BNP,
+                CRP, CJP, CNP,
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
+        BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
+        CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
+        RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
+    then<ARF = never, AJF = never, ANF = never,
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never,
+        ARP = never, AJP = never, ANP = never,
+        BRP = never, BJP = never, BNP = never,
+        CRP = never, CJP = never, CNP = never,
+        RRP = never, RJP = never, RNP = never>(
+            doneFilter: null,
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                BRP, BJP, BNP,
+                CRP, CJP, CNP,
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
+        BRF | BRP, BJF | BJP, BNF | BNP,
+        CRF | CRP, CJF | CJP, CNF | CNP,
+        RRF | RRP, RJF | RJP, RNF | RNP>;
+    then<ARP = never, AJP = never, ANP = never,
+        BRP = never, BJP = never, BNP = never,
+        CRP = never, CJP = never, CNP = never,
+        RRP = never, RJP = never, RNP = never>(
+            doneFilter: null,
+            failFilter: null,
+            progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                BRP, BJP, BNP,
+                CRP, CJP, CNP,
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
+        BRP, BJP, BNP,
+        CRP, CJP, CNP,
+        RRP, RJP, RNP>;
+    then<ARD = never, AJD = never, AND = never,
+        BRD = never, BJD = never, BND = never,
+        CRD = never, CJD = never, CND = never,
+        RRD = never, RJD = never, RND = never,
+        ARF = never, AJF = never, ANF = never,
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never>(
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                BRD, BJD, BND,
+                CRD, CJD, CND,
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
+        BRD | BRF, BJD | BJF, BND | BNF,
+        CRD | CRF, CJD | CJF, CND | CNF,
+        RRD | RRF, RJD | RJF, RND | RNF>;
+    then<ARF = never, AJF = never, ANF = never,
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never>(
+            doneFilter: null,
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter?: null): PromiseBase<ARF, AJF, ANF,
+        BRF, BJF, BNF,
+        CRF, CJF, CNF,
+        RRF, RJF, RNF>;
+    then<ARD = never, AJD = never, AND = never,
+        BRD = never, BJD = never, BND = never,
+        CRD = never, CJD = never, CND = never,
+        RRD = never, RJD = never, RND = never>(
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                BRD, BJD, BND,
+                CRD, CJD, CND,
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+            failFilter?: null,
+            progressFilter?: null): PromiseBase<ARD, AJD, AND,
+        BRD, BJD, BND,
+        CRD, CJD, CND,
+        RRD, RJD, RND>;
+}
+
+interface Promise3<TR, TJ, TN,
+    UR, UJ, UN,
+    VR, VJ, VN> extends PromiseBase<TR, TJ, TN,
+    UR, UJ, UN,
+    VR, VJ, VN,
+    never, never, never> { }
+
+type T = Awaited<Promise3<string, Error, number, {}, string, boolean, any, Element, never>>; // string
+
+//// [awaitedTypeJQuery.js]
+/// <reference lib="dom" />
diff --git a/tests/baselines/reference/awaitedTypeJQuery.symbols b/tests/baselines/reference/awaitedTypeJQuery.symbols
new file mode 100644
index 0000000000000..ca774f76bdb26
--- /dev/null
+++ b/tests/baselines/reference/awaitedTypeJQuery.symbols
@@ -0,0 +1,793 @@
+=== tests/cases/compiler/awaitedTypeJQuery.ts ===
+/// <reference lib="dom" />
+
+interface Thenable<T> extends PromiseLike<T> { }
+>Thenable : Symbol(Thenable, Decl(awaitedTypeJQuery.ts, 0, 0))
+>T : Symbol(T, Decl(awaitedTypeJQuery.ts, 2, 19))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(awaitedTypeJQuery.ts, 2, 19))
+
+// JQuery's Promise type
+interface PromiseBase<TR, TJ, TN,
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>TR : Symbol(TR, Decl(awaitedTypeJQuery.ts, 5, 22))
+>TJ : Symbol(TJ, Decl(awaitedTypeJQuery.ts, 5, 25))
+>TN : Symbol(TN, Decl(awaitedTypeJQuery.ts, 5, 29))
+
+    UR, UJ, UN,
+>UR : Symbol(UR, Decl(awaitedTypeJQuery.ts, 5, 33))
+>UJ : Symbol(UJ, Decl(awaitedTypeJQuery.ts, 6, 7))
+>UN : Symbol(UN, Decl(awaitedTypeJQuery.ts, 6, 11))
+
+    VR, VJ, VN,
+>VR : Symbol(VR, Decl(awaitedTypeJQuery.ts, 6, 15))
+>VJ : Symbol(VJ, Decl(awaitedTypeJQuery.ts, 7, 7))
+>VN : Symbol(VN, Decl(awaitedTypeJQuery.ts, 7, 11))
+
+    SR, SJ, SN> {
+>SR : Symbol(SR, Decl(awaitedTypeJQuery.ts, 7, 15))
+>SJ : Symbol(SJ, Decl(awaitedTypeJQuery.ts, 8, 7))
+>SN : Symbol(SN, Decl(awaitedTypeJQuery.ts, 8, 11))
+
+    then<ARD = never, AJD = never, AND = never,
+>then : Symbol(PromiseBase.then, Decl(awaitedTypeJQuery.ts, 8, 17), Decl(awaitedTypeJQuery.ts, 35, 59), Decl(awaitedTypeJQuery.ts, 55, 41), Decl(awaitedTypeJQuery.ts, 68, 23), Decl(awaitedTypeJQuery.ts, 88, 41) ... and 1 more)
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 9, 9))
+>AJD : Symbol(AJD, Decl(awaitedTypeJQuery.ts, 9, 21))
+>AND : Symbol(AND, Decl(awaitedTypeJQuery.ts, 9, 34))
+
+        BRD = never, BJD = never, BND = never,
+>BRD : Symbol(BRD, Decl(awaitedTypeJQuery.ts, 9, 47))
+>BJD : Symbol(BJD, Decl(awaitedTypeJQuery.ts, 10, 20))
+>BND : Symbol(BND, Decl(awaitedTypeJQuery.ts, 10, 33))
+
+        CRD = never, CJD = never, CND = never,
+>CRD : Symbol(CRD, Decl(awaitedTypeJQuery.ts, 10, 46))
+>CJD : Symbol(CJD, Decl(awaitedTypeJQuery.ts, 11, 20))
+>CND : Symbol(CND, Decl(awaitedTypeJQuery.ts, 11, 33))
+
+        RRD = never, RJD = never, RND = never,
+>RRD : Symbol(RRD, Decl(awaitedTypeJQuery.ts, 11, 46))
+>RJD : Symbol(RJD, Decl(awaitedTypeJQuery.ts, 12, 20))
+>RND : Symbol(RND, Decl(awaitedTypeJQuery.ts, 12, 33))
+
+        ARF = never, AJF = never, ANF = never,
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 12, 46))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 13, 20))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 13, 33))
+
+        BRF = never, BJF = never, BNF = never,
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 13, 46))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 14, 20))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 14, 33))
+
+        CRF = never, CJF = never, CNF = never,
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 14, 46))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 15, 20))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 15, 33))
+
+        RRF = never, RJF = never, RNF = never,
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 15, 46))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 16, 20))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 16, 33))
+
+        ARP = never, AJP = never, ANP = never,
+>ARP : Symbol(ARP, Decl(awaitedTypeJQuery.ts, 16, 46))
+>AJP : Symbol(AJP, Decl(awaitedTypeJQuery.ts, 17, 20))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 17, 33))
+
+        BRP = never, BJP = never, BNP = never,
+>BRP : Symbol(BRP, Decl(awaitedTypeJQuery.ts, 17, 46))
+>BJP : Symbol(BJP, Decl(awaitedTypeJQuery.ts, 18, 20))
+>BNP : Symbol(BNP, Decl(awaitedTypeJQuery.ts, 18, 33))
+
+        CRP = never, CJP = never, CNP = never,
+>CRP : Symbol(CRP, Decl(awaitedTypeJQuery.ts, 18, 46))
+>CJP : Symbol(CJP, Decl(awaitedTypeJQuery.ts, 19, 20))
+>CNP : Symbol(CNP, Decl(awaitedTypeJQuery.ts, 19, 33))
+
+        RRP = never, RJP = never, RNP = never>(
+>RRP : Symbol(RRP, Decl(awaitedTypeJQuery.ts, 19, 46))
+>RJP : Symbol(RJP, Decl(awaitedTypeJQuery.ts, 20, 20))
+>RNP : Symbol(RNP, Decl(awaitedTypeJQuery.ts, 20, 33))
+
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+>doneFilter : Symbol(doneFilter, Decl(awaitedTypeJQuery.ts, 20, 47))
+>t : Symbol(t, Decl(awaitedTypeJQuery.ts, 21, 25))
+>TR : Symbol(TR, Decl(awaitedTypeJQuery.ts, 5, 22))
+>u : Symbol(u, Decl(awaitedTypeJQuery.ts, 21, 31))
+>UR : Symbol(UR, Decl(awaitedTypeJQuery.ts, 5, 33))
+>v : Symbol(v, Decl(awaitedTypeJQuery.ts, 21, 38))
+>VR : Symbol(VR, Decl(awaitedTypeJQuery.ts, 6, 15))
+>s : Symbol(s, Decl(awaitedTypeJQuery.ts, 21, 45))
+>SR : Symbol(SR, Decl(awaitedTypeJQuery.ts, 7, 15))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 9, 9))
+>AJD : Symbol(AJD, Decl(awaitedTypeJQuery.ts, 9, 21))
+>AND : Symbol(AND, Decl(awaitedTypeJQuery.ts, 9, 34))
+
+                BRD, BJD, BND,
+>BRD : Symbol(BRD, Decl(awaitedTypeJQuery.ts, 9, 47))
+>BJD : Symbol(BJD, Decl(awaitedTypeJQuery.ts, 10, 20))
+>BND : Symbol(BND, Decl(awaitedTypeJQuery.ts, 10, 33))
+
+                CRD, CJD, CND,
+>CRD : Symbol(CRD, Decl(awaitedTypeJQuery.ts, 10, 46))
+>CJD : Symbol(CJD, Decl(awaitedTypeJQuery.ts, 11, 20))
+>CND : Symbol(CND, Decl(awaitedTypeJQuery.ts, 11, 33))
+
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+>RRD : Symbol(RRD, Decl(awaitedTypeJQuery.ts, 11, 46))
+>RJD : Symbol(RJD, Decl(awaitedTypeJQuery.ts, 12, 20))
+>RND : Symbol(RND, Decl(awaitedTypeJQuery.ts, 12, 33))
+>Thenable : Symbol(Thenable, Decl(awaitedTypeJQuery.ts, 0, 0))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 9, 9))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 9, 9))
+
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+>failFilter : Symbol(failFilter, Decl(awaitedTypeJQuery.ts, 24, 53))
+>t : Symbol(t, Decl(awaitedTypeJQuery.ts, 25, 25))
+>TJ : Symbol(TJ, Decl(awaitedTypeJQuery.ts, 5, 25))
+>u : Symbol(u, Decl(awaitedTypeJQuery.ts, 25, 31))
+>UJ : Symbol(UJ, Decl(awaitedTypeJQuery.ts, 6, 7))
+>v : Symbol(v, Decl(awaitedTypeJQuery.ts, 25, 38))
+>VJ : Symbol(VJ, Decl(awaitedTypeJQuery.ts, 7, 7))
+>s : Symbol(s, Decl(awaitedTypeJQuery.ts, 25, 45))
+>SJ : Symbol(SJ, Decl(awaitedTypeJQuery.ts, 8, 7))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 12, 46))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 13, 20))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 13, 33))
+
+                BRF, BJF, BNF,
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 13, 46))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 14, 20))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 14, 33))
+
+                CRF, CJF, CNF,
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 14, 46))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 15, 20))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 15, 33))
+
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 15, 46))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 16, 20))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 16, 33))
+>Thenable : Symbol(Thenable, Decl(awaitedTypeJQuery.ts, 0, 0))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 12, 46))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 12, 46))
+
+            progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+>progressFilter : Symbol(progressFilter, Decl(awaitedTypeJQuery.ts, 28, 53))
+>t : Symbol(t, Decl(awaitedTypeJQuery.ts, 29, 29))
+>TN : Symbol(TN, Decl(awaitedTypeJQuery.ts, 5, 29))
+>u : Symbol(u, Decl(awaitedTypeJQuery.ts, 29, 35))
+>UN : Symbol(UN, Decl(awaitedTypeJQuery.ts, 6, 11))
+>v : Symbol(v, Decl(awaitedTypeJQuery.ts, 29, 42))
+>VN : Symbol(VN, Decl(awaitedTypeJQuery.ts, 7, 11))
+>s : Symbol(s, Decl(awaitedTypeJQuery.ts, 29, 49))
+>SN : Symbol(SN, Decl(awaitedTypeJQuery.ts, 8, 11))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARP : Symbol(ARP, Decl(awaitedTypeJQuery.ts, 16, 46))
+>AJP : Symbol(AJP, Decl(awaitedTypeJQuery.ts, 17, 20))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 17, 33))
+
+                BRP, BJP, BNP,
+>BRP : Symbol(BRP, Decl(awaitedTypeJQuery.ts, 17, 46))
+>BJP : Symbol(BJP, Decl(awaitedTypeJQuery.ts, 18, 20))
+>BNP : Symbol(BNP, Decl(awaitedTypeJQuery.ts, 18, 33))
+
+                CRP, CJP, CNP,
+>CRP : Symbol(CRP, Decl(awaitedTypeJQuery.ts, 18, 46))
+>CJP : Symbol(CJP, Decl(awaitedTypeJQuery.ts, 19, 20))
+>CNP : Symbol(CNP, Decl(awaitedTypeJQuery.ts, 19, 33))
+
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
+>RRP : Symbol(RRP, Decl(awaitedTypeJQuery.ts, 19, 46))
+>RJP : Symbol(RJP, Decl(awaitedTypeJQuery.ts, 20, 20))
+>RNP : Symbol(RNP, Decl(awaitedTypeJQuery.ts, 20, 33))
+>Thenable : Symbol(Thenable, Decl(awaitedTypeJQuery.ts, 0, 0))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 17, 33))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 17, 33))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 9, 9))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 12, 46))
+>ARP : Symbol(ARP, Decl(awaitedTypeJQuery.ts, 16, 46))
+>AJD : Symbol(AJD, Decl(awaitedTypeJQuery.ts, 9, 21))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 13, 20))
+>AJP : Symbol(AJP, Decl(awaitedTypeJQuery.ts, 17, 20))
+>AND : Symbol(AND, Decl(awaitedTypeJQuery.ts, 9, 34))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 13, 33))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 17, 33))
+
+        BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
+>BRD : Symbol(BRD, Decl(awaitedTypeJQuery.ts, 9, 47))
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 13, 46))
+>BRP : Symbol(BRP, Decl(awaitedTypeJQuery.ts, 17, 46))
+>BJD : Symbol(BJD, Decl(awaitedTypeJQuery.ts, 10, 20))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 14, 20))
+>BJP : Symbol(BJP, Decl(awaitedTypeJQuery.ts, 18, 20))
+>BND : Symbol(BND, Decl(awaitedTypeJQuery.ts, 10, 33))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 14, 33))
+>BNP : Symbol(BNP, Decl(awaitedTypeJQuery.ts, 18, 33))
+
+        CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
+>CRD : Symbol(CRD, Decl(awaitedTypeJQuery.ts, 10, 46))
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 14, 46))
+>CRP : Symbol(CRP, Decl(awaitedTypeJQuery.ts, 18, 46))
+>CJD : Symbol(CJD, Decl(awaitedTypeJQuery.ts, 11, 20))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 15, 20))
+>CJP : Symbol(CJP, Decl(awaitedTypeJQuery.ts, 19, 20))
+>CND : Symbol(CND, Decl(awaitedTypeJQuery.ts, 11, 33))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 15, 33))
+>CNP : Symbol(CNP, Decl(awaitedTypeJQuery.ts, 19, 33))
+
+        RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
+>RRD : Symbol(RRD, Decl(awaitedTypeJQuery.ts, 11, 46))
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 15, 46))
+>RRP : Symbol(RRP, Decl(awaitedTypeJQuery.ts, 19, 46))
+>RJD : Symbol(RJD, Decl(awaitedTypeJQuery.ts, 12, 20))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 16, 20))
+>RJP : Symbol(RJP, Decl(awaitedTypeJQuery.ts, 20, 20))
+>RND : Symbol(RND, Decl(awaitedTypeJQuery.ts, 12, 33))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 16, 33))
+>RNP : Symbol(RNP, Decl(awaitedTypeJQuery.ts, 20, 33))
+
+    then<ARF = never, AJF = never, ANF = never,
+>then : Symbol(PromiseBase.then, Decl(awaitedTypeJQuery.ts, 8, 17), Decl(awaitedTypeJQuery.ts, 35, 59), Decl(awaitedTypeJQuery.ts, 55, 41), Decl(awaitedTypeJQuery.ts, 68, 23), Decl(awaitedTypeJQuery.ts, 88, 41) ... and 1 more)
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 36, 9))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 36, 21))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 36, 34))
+
+        BRF = never, BJF = never, BNF = never,
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 36, 47))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 37, 20))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 37, 33))
+
+        CRF = never, CJF = never, CNF = never,
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 37, 46))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 38, 20))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 38, 33))
+
+        RRF = never, RJF = never, RNF = never,
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 38, 46))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 39, 20))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 39, 33))
+
+        ARP = never, AJP = never, ANP = never,
+>ARP : Symbol(ARP, Decl(awaitedTypeJQuery.ts, 39, 46))
+>AJP : Symbol(AJP, Decl(awaitedTypeJQuery.ts, 40, 20))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 40, 33))
+
+        BRP = never, BJP = never, BNP = never,
+>BRP : Symbol(BRP, Decl(awaitedTypeJQuery.ts, 40, 46))
+>BJP : Symbol(BJP, Decl(awaitedTypeJQuery.ts, 41, 20))
+>BNP : Symbol(BNP, Decl(awaitedTypeJQuery.ts, 41, 33))
+
+        CRP = never, CJP = never, CNP = never,
+>CRP : Symbol(CRP, Decl(awaitedTypeJQuery.ts, 41, 46))
+>CJP : Symbol(CJP, Decl(awaitedTypeJQuery.ts, 42, 20))
+>CNP : Symbol(CNP, Decl(awaitedTypeJQuery.ts, 42, 33))
+
+        RRP = never, RJP = never, RNP = never>(
+>RRP : Symbol(RRP, Decl(awaitedTypeJQuery.ts, 42, 46))
+>RJP : Symbol(RJP, Decl(awaitedTypeJQuery.ts, 43, 20))
+>RNP : Symbol(RNP, Decl(awaitedTypeJQuery.ts, 43, 33))
+
+            doneFilter: null,
+>doneFilter : Symbol(doneFilter, Decl(awaitedTypeJQuery.ts, 43, 47))
+
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+>failFilter : Symbol(failFilter, Decl(awaitedTypeJQuery.ts, 44, 29))
+>t : Symbol(t, Decl(awaitedTypeJQuery.ts, 45, 25))
+>TJ : Symbol(TJ, Decl(awaitedTypeJQuery.ts, 5, 25))
+>u : Symbol(u, Decl(awaitedTypeJQuery.ts, 45, 31))
+>UJ : Symbol(UJ, Decl(awaitedTypeJQuery.ts, 6, 7))
+>v : Symbol(v, Decl(awaitedTypeJQuery.ts, 45, 38))
+>VJ : Symbol(VJ, Decl(awaitedTypeJQuery.ts, 7, 7))
+>s : Symbol(s, Decl(awaitedTypeJQuery.ts, 45, 45))
+>SJ : Symbol(SJ, Decl(awaitedTypeJQuery.ts, 8, 7))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 36, 9))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 36, 21))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 36, 34))
+
+                BRF, BJF, BNF,
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 36, 47))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 37, 20))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 37, 33))
+
+                CRF, CJF, CNF,
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 37, 46))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 38, 20))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 38, 33))
+
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 38, 46))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 39, 20))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 39, 33))
+>Thenable : Symbol(Thenable, Decl(awaitedTypeJQuery.ts, 0, 0))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 36, 9))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 36, 9))
+
+            progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+>progressFilter : Symbol(progressFilter, Decl(awaitedTypeJQuery.ts, 48, 53))
+>t : Symbol(t, Decl(awaitedTypeJQuery.ts, 49, 29))
+>TN : Symbol(TN, Decl(awaitedTypeJQuery.ts, 5, 29))
+>u : Symbol(u, Decl(awaitedTypeJQuery.ts, 49, 35))
+>UN : Symbol(UN, Decl(awaitedTypeJQuery.ts, 6, 11))
+>v : Symbol(v, Decl(awaitedTypeJQuery.ts, 49, 42))
+>VN : Symbol(VN, Decl(awaitedTypeJQuery.ts, 7, 11))
+>s : Symbol(s, Decl(awaitedTypeJQuery.ts, 49, 49))
+>SN : Symbol(SN, Decl(awaitedTypeJQuery.ts, 8, 11))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARP : Symbol(ARP, Decl(awaitedTypeJQuery.ts, 39, 46))
+>AJP : Symbol(AJP, Decl(awaitedTypeJQuery.ts, 40, 20))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 40, 33))
+
+                BRP, BJP, BNP,
+>BRP : Symbol(BRP, Decl(awaitedTypeJQuery.ts, 40, 46))
+>BJP : Symbol(BJP, Decl(awaitedTypeJQuery.ts, 41, 20))
+>BNP : Symbol(BNP, Decl(awaitedTypeJQuery.ts, 41, 33))
+
+                CRP, CJP, CNP,
+>CRP : Symbol(CRP, Decl(awaitedTypeJQuery.ts, 41, 46))
+>CJP : Symbol(CJP, Decl(awaitedTypeJQuery.ts, 42, 20))
+>CNP : Symbol(CNP, Decl(awaitedTypeJQuery.ts, 42, 33))
+
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
+>RRP : Symbol(RRP, Decl(awaitedTypeJQuery.ts, 42, 46))
+>RJP : Symbol(RJP, Decl(awaitedTypeJQuery.ts, 43, 20))
+>RNP : Symbol(RNP, Decl(awaitedTypeJQuery.ts, 43, 33))
+>Thenable : Symbol(Thenable, Decl(awaitedTypeJQuery.ts, 0, 0))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 40, 33))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 40, 33))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 36, 9))
+>ARP : Symbol(ARP, Decl(awaitedTypeJQuery.ts, 39, 46))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 36, 21))
+>AJP : Symbol(AJP, Decl(awaitedTypeJQuery.ts, 40, 20))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 36, 34))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 40, 33))
+
+        BRF | BRP, BJF | BJP, BNF | BNP,
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 36, 47))
+>BRP : Symbol(BRP, Decl(awaitedTypeJQuery.ts, 40, 46))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 37, 20))
+>BJP : Symbol(BJP, Decl(awaitedTypeJQuery.ts, 41, 20))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 37, 33))
+>BNP : Symbol(BNP, Decl(awaitedTypeJQuery.ts, 41, 33))
+
+        CRF | CRP, CJF | CJP, CNF | CNP,
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 37, 46))
+>CRP : Symbol(CRP, Decl(awaitedTypeJQuery.ts, 41, 46))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 38, 20))
+>CJP : Symbol(CJP, Decl(awaitedTypeJQuery.ts, 42, 20))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 38, 33))
+>CNP : Symbol(CNP, Decl(awaitedTypeJQuery.ts, 42, 33))
+
+        RRF | RRP, RJF | RJP, RNF | RNP>;
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 38, 46))
+>RRP : Symbol(RRP, Decl(awaitedTypeJQuery.ts, 42, 46))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 39, 20))
+>RJP : Symbol(RJP, Decl(awaitedTypeJQuery.ts, 43, 20))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 39, 33))
+>RNP : Symbol(RNP, Decl(awaitedTypeJQuery.ts, 43, 33))
+
+    then<ARP = never, AJP = never, ANP = never,
+>then : Symbol(PromiseBase.then, Decl(awaitedTypeJQuery.ts, 8, 17), Decl(awaitedTypeJQuery.ts, 35, 59), Decl(awaitedTypeJQuery.ts, 55, 41), Decl(awaitedTypeJQuery.ts, 68, 23), Decl(awaitedTypeJQuery.ts, 88, 41) ... and 1 more)
+>ARP : Symbol(ARP, Decl(awaitedTypeJQuery.ts, 56, 9))
+>AJP : Symbol(AJP, Decl(awaitedTypeJQuery.ts, 56, 21))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 56, 34))
+
+        BRP = never, BJP = never, BNP = never,
+>BRP : Symbol(BRP, Decl(awaitedTypeJQuery.ts, 56, 47))
+>BJP : Symbol(BJP, Decl(awaitedTypeJQuery.ts, 57, 20))
+>BNP : Symbol(BNP, Decl(awaitedTypeJQuery.ts, 57, 33))
+
+        CRP = never, CJP = never, CNP = never,
+>CRP : Symbol(CRP, Decl(awaitedTypeJQuery.ts, 57, 46))
+>CJP : Symbol(CJP, Decl(awaitedTypeJQuery.ts, 58, 20))
+>CNP : Symbol(CNP, Decl(awaitedTypeJQuery.ts, 58, 33))
+
+        RRP = never, RJP = never, RNP = never>(
+>RRP : Symbol(RRP, Decl(awaitedTypeJQuery.ts, 58, 46))
+>RJP : Symbol(RJP, Decl(awaitedTypeJQuery.ts, 59, 20))
+>RNP : Symbol(RNP, Decl(awaitedTypeJQuery.ts, 59, 33))
+
+            doneFilter: null,
+>doneFilter : Symbol(doneFilter, Decl(awaitedTypeJQuery.ts, 59, 47))
+
+            failFilter: null,
+>failFilter : Symbol(failFilter, Decl(awaitedTypeJQuery.ts, 60, 29))
+
+            progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+>progressFilter : Symbol(progressFilter, Decl(awaitedTypeJQuery.ts, 61, 29))
+>t : Symbol(t, Decl(awaitedTypeJQuery.ts, 62, 30))
+>TN : Symbol(TN, Decl(awaitedTypeJQuery.ts, 5, 29))
+>u : Symbol(u, Decl(awaitedTypeJQuery.ts, 62, 36))
+>UN : Symbol(UN, Decl(awaitedTypeJQuery.ts, 6, 11))
+>v : Symbol(v, Decl(awaitedTypeJQuery.ts, 62, 43))
+>VN : Symbol(VN, Decl(awaitedTypeJQuery.ts, 7, 11))
+>s : Symbol(s, Decl(awaitedTypeJQuery.ts, 62, 50))
+>SN : Symbol(SN, Decl(awaitedTypeJQuery.ts, 8, 11))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARP : Symbol(ARP, Decl(awaitedTypeJQuery.ts, 56, 9))
+>AJP : Symbol(AJP, Decl(awaitedTypeJQuery.ts, 56, 21))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 56, 34))
+
+                BRP, BJP, BNP,
+>BRP : Symbol(BRP, Decl(awaitedTypeJQuery.ts, 56, 47))
+>BJP : Symbol(BJP, Decl(awaitedTypeJQuery.ts, 57, 20))
+>BNP : Symbol(BNP, Decl(awaitedTypeJQuery.ts, 57, 33))
+
+                CRP, CJP, CNP,
+>CRP : Symbol(CRP, Decl(awaitedTypeJQuery.ts, 57, 46))
+>CJP : Symbol(CJP, Decl(awaitedTypeJQuery.ts, 58, 20))
+>CNP : Symbol(CNP, Decl(awaitedTypeJQuery.ts, 58, 33))
+
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
+>RRP : Symbol(RRP, Decl(awaitedTypeJQuery.ts, 58, 46))
+>RJP : Symbol(RJP, Decl(awaitedTypeJQuery.ts, 59, 20))
+>RNP : Symbol(RNP, Decl(awaitedTypeJQuery.ts, 59, 33))
+>Thenable : Symbol(Thenable, Decl(awaitedTypeJQuery.ts, 0, 0))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 56, 34))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 56, 34))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARP : Symbol(ARP, Decl(awaitedTypeJQuery.ts, 56, 9))
+>AJP : Symbol(AJP, Decl(awaitedTypeJQuery.ts, 56, 21))
+>ANP : Symbol(ANP, Decl(awaitedTypeJQuery.ts, 56, 34))
+
+        BRP, BJP, BNP,
+>BRP : Symbol(BRP, Decl(awaitedTypeJQuery.ts, 56, 47))
+>BJP : Symbol(BJP, Decl(awaitedTypeJQuery.ts, 57, 20))
+>BNP : Symbol(BNP, Decl(awaitedTypeJQuery.ts, 57, 33))
+
+        CRP, CJP, CNP,
+>CRP : Symbol(CRP, Decl(awaitedTypeJQuery.ts, 57, 46))
+>CJP : Symbol(CJP, Decl(awaitedTypeJQuery.ts, 58, 20))
+>CNP : Symbol(CNP, Decl(awaitedTypeJQuery.ts, 58, 33))
+
+        RRP, RJP, RNP>;
+>RRP : Symbol(RRP, Decl(awaitedTypeJQuery.ts, 58, 46))
+>RJP : Symbol(RJP, Decl(awaitedTypeJQuery.ts, 59, 20))
+>RNP : Symbol(RNP, Decl(awaitedTypeJQuery.ts, 59, 33))
+
+    then<ARD = never, AJD = never, AND = never,
+>then : Symbol(PromiseBase.then, Decl(awaitedTypeJQuery.ts, 8, 17), Decl(awaitedTypeJQuery.ts, 35, 59), Decl(awaitedTypeJQuery.ts, 55, 41), Decl(awaitedTypeJQuery.ts, 68, 23), Decl(awaitedTypeJQuery.ts, 88, 41) ... and 1 more)
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 69, 9))
+>AJD : Symbol(AJD, Decl(awaitedTypeJQuery.ts, 69, 21))
+>AND : Symbol(AND, Decl(awaitedTypeJQuery.ts, 69, 34))
+
+        BRD = never, BJD = never, BND = never,
+>BRD : Symbol(BRD, Decl(awaitedTypeJQuery.ts, 69, 47))
+>BJD : Symbol(BJD, Decl(awaitedTypeJQuery.ts, 70, 20))
+>BND : Symbol(BND, Decl(awaitedTypeJQuery.ts, 70, 33))
+
+        CRD = never, CJD = never, CND = never,
+>CRD : Symbol(CRD, Decl(awaitedTypeJQuery.ts, 70, 46))
+>CJD : Symbol(CJD, Decl(awaitedTypeJQuery.ts, 71, 20))
+>CND : Symbol(CND, Decl(awaitedTypeJQuery.ts, 71, 33))
+
+        RRD = never, RJD = never, RND = never,
+>RRD : Symbol(RRD, Decl(awaitedTypeJQuery.ts, 71, 46))
+>RJD : Symbol(RJD, Decl(awaitedTypeJQuery.ts, 72, 20))
+>RND : Symbol(RND, Decl(awaitedTypeJQuery.ts, 72, 33))
+
+        ARF = never, AJF = never, ANF = never,
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 72, 46))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 73, 20))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 73, 33))
+
+        BRF = never, BJF = never, BNF = never,
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 73, 46))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 74, 20))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 74, 33))
+
+        CRF = never, CJF = never, CNF = never,
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 74, 46))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 75, 20))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 75, 33))
+
+        RRF = never, RJF = never, RNF = never>(
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 75, 46))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 76, 20))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 76, 33))
+
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+>doneFilter : Symbol(doneFilter, Decl(awaitedTypeJQuery.ts, 76, 47))
+>t : Symbol(t, Decl(awaitedTypeJQuery.ts, 77, 25))
+>TR : Symbol(TR, Decl(awaitedTypeJQuery.ts, 5, 22))
+>u : Symbol(u, Decl(awaitedTypeJQuery.ts, 77, 31))
+>UR : Symbol(UR, Decl(awaitedTypeJQuery.ts, 5, 33))
+>v : Symbol(v, Decl(awaitedTypeJQuery.ts, 77, 38))
+>VR : Symbol(VR, Decl(awaitedTypeJQuery.ts, 6, 15))
+>s : Symbol(s, Decl(awaitedTypeJQuery.ts, 77, 45))
+>SR : Symbol(SR, Decl(awaitedTypeJQuery.ts, 7, 15))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 69, 9))
+>AJD : Symbol(AJD, Decl(awaitedTypeJQuery.ts, 69, 21))
+>AND : Symbol(AND, Decl(awaitedTypeJQuery.ts, 69, 34))
+
+                BRD, BJD, BND,
+>BRD : Symbol(BRD, Decl(awaitedTypeJQuery.ts, 69, 47))
+>BJD : Symbol(BJD, Decl(awaitedTypeJQuery.ts, 70, 20))
+>BND : Symbol(BND, Decl(awaitedTypeJQuery.ts, 70, 33))
+
+                CRD, CJD, CND,
+>CRD : Symbol(CRD, Decl(awaitedTypeJQuery.ts, 70, 46))
+>CJD : Symbol(CJD, Decl(awaitedTypeJQuery.ts, 71, 20))
+>CND : Symbol(CND, Decl(awaitedTypeJQuery.ts, 71, 33))
+
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+>RRD : Symbol(RRD, Decl(awaitedTypeJQuery.ts, 71, 46))
+>RJD : Symbol(RJD, Decl(awaitedTypeJQuery.ts, 72, 20))
+>RND : Symbol(RND, Decl(awaitedTypeJQuery.ts, 72, 33))
+>Thenable : Symbol(Thenable, Decl(awaitedTypeJQuery.ts, 0, 0))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 69, 9))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 69, 9))
+
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+>failFilter : Symbol(failFilter, Decl(awaitedTypeJQuery.ts, 80, 53))
+>t : Symbol(t, Decl(awaitedTypeJQuery.ts, 81, 25))
+>TJ : Symbol(TJ, Decl(awaitedTypeJQuery.ts, 5, 25))
+>u : Symbol(u, Decl(awaitedTypeJQuery.ts, 81, 31))
+>UJ : Symbol(UJ, Decl(awaitedTypeJQuery.ts, 6, 7))
+>v : Symbol(v, Decl(awaitedTypeJQuery.ts, 81, 38))
+>VJ : Symbol(VJ, Decl(awaitedTypeJQuery.ts, 7, 7))
+>s : Symbol(s, Decl(awaitedTypeJQuery.ts, 81, 45))
+>SJ : Symbol(SJ, Decl(awaitedTypeJQuery.ts, 8, 7))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 72, 46))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 73, 20))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 73, 33))
+
+                BRF, BJF, BNF,
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 73, 46))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 74, 20))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 74, 33))
+
+                CRF, CJF, CNF,
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 74, 46))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 75, 20))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 75, 33))
+
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 75, 46))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 76, 20))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 76, 33))
+>Thenable : Symbol(Thenable, Decl(awaitedTypeJQuery.ts, 0, 0))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 72, 46))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 72, 46))
+
+            progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
+>progressFilter : Symbol(progressFilter, Decl(awaitedTypeJQuery.ts, 84, 53))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 69, 9))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 72, 46))
+>AJD : Symbol(AJD, Decl(awaitedTypeJQuery.ts, 69, 21))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 73, 20))
+>AND : Symbol(AND, Decl(awaitedTypeJQuery.ts, 69, 34))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 73, 33))
+
+        BRD | BRF, BJD | BJF, BND | BNF,
+>BRD : Symbol(BRD, Decl(awaitedTypeJQuery.ts, 69, 47))
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 73, 46))
+>BJD : Symbol(BJD, Decl(awaitedTypeJQuery.ts, 70, 20))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 74, 20))
+>BND : Symbol(BND, Decl(awaitedTypeJQuery.ts, 70, 33))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 74, 33))
+
+        CRD | CRF, CJD | CJF, CND | CNF,
+>CRD : Symbol(CRD, Decl(awaitedTypeJQuery.ts, 70, 46))
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 74, 46))
+>CJD : Symbol(CJD, Decl(awaitedTypeJQuery.ts, 71, 20))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 75, 20))
+>CND : Symbol(CND, Decl(awaitedTypeJQuery.ts, 71, 33))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 75, 33))
+
+        RRD | RRF, RJD | RJF, RND | RNF>;
+>RRD : Symbol(RRD, Decl(awaitedTypeJQuery.ts, 71, 46))
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 75, 46))
+>RJD : Symbol(RJD, Decl(awaitedTypeJQuery.ts, 72, 20))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 76, 20))
+>RND : Symbol(RND, Decl(awaitedTypeJQuery.ts, 72, 33))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 76, 33))
+
+    then<ARF = never, AJF = never, ANF = never,
+>then : Symbol(PromiseBase.then, Decl(awaitedTypeJQuery.ts, 8, 17), Decl(awaitedTypeJQuery.ts, 35, 59), Decl(awaitedTypeJQuery.ts, 55, 41), Decl(awaitedTypeJQuery.ts, 68, 23), Decl(awaitedTypeJQuery.ts, 88, 41) ... and 1 more)
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 89, 9))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 89, 21))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 89, 34))
+
+        BRF = never, BJF = never, BNF = never,
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 89, 47))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 90, 20))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 90, 33))
+
+        CRF = never, CJF = never, CNF = never,
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 90, 46))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 91, 20))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 91, 33))
+
+        RRF = never, RJF = never, RNF = never>(
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 91, 46))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 92, 20))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 92, 33))
+
+            doneFilter: null,
+>doneFilter : Symbol(doneFilter, Decl(awaitedTypeJQuery.ts, 92, 47))
+
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+>failFilter : Symbol(failFilter, Decl(awaitedTypeJQuery.ts, 93, 29))
+>t : Symbol(t, Decl(awaitedTypeJQuery.ts, 94, 25))
+>TJ : Symbol(TJ, Decl(awaitedTypeJQuery.ts, 5, 25))
+>u : Symbol(u, Decl(awaitedTypeJQuery.ts, 94, 31))
+>UJ : Symbol(UJ, Decl(awaitedTypeJQuery.ts, 6, 7))
+>v : Symbol(v, Decl(awaitedTypeJQuery.ts, 94, 38))
+>VJ : Symbol(VJ, Decl(awaitedTypeJQuery.ts, 7, 7))
+>s : Symbol(s, Decl(awaitedTypeJQuery.ts, 94, 45))
+>SJ : Symbol(SJ, Decl(awaitedTypeJQuery.ts, 8, 7))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 89, 9))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 89, 21))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 89, 34))
+
+                BRF, BJF, BNF,
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 89, 47))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 90, 20))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 90, 33))
+
+                CRF, CJF, CNF,
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 90, 46))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 91, 20))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 91, 33))
+
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 91, 46))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 92, 20))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 92, 33))
+>Thenable : Symbol(Thenable, Decl(awaitedTypeJQuery.ts, 0, 0))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 89, 9))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 89, 9))
+
+            progressFilter?: null): PromiseBase<ARF, AJF, ANF,
+>progressFilter : Symbol(progressFilter, Decl(awaitedTypeJQuery.ts, 97, 53))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARF : Symbol(ARF, Decl(awaitedTypeJQuery.ts, 89, 9))
+>AJF : Symbol(AJF, Decl(awaitedTypeJQuery.ts, 89, 21))
+>ANF : Symbol(ANF, Decl(awaitedTypeJQuery.ts, 89, 34))
+
+        BRF, BJF, BNF,
+>BRF : Symbol(BRF, Decl(awaitedTypeJQuery.ts, 89, 47))
+>BJF : Symbol(BJF, Decl(awaitedTypeJQuery.ts, 90, 20))
+>BNF : Symbol(BNF, Decl(awaitedTypeJQuery.ts, 90, 33))
+
+        CRF, CJF, CNF,
+>CRF : Symbol(CRF, Decl(awaitedTypeJQuery.ts, 90, 46))
+>CJF : Symbol(CJF, Decl(awaitedTypeJQuery.ts, 91, 20))
+>CNF : Symbol(CNF, Decl(awaitedTypeJQuery.ts, 91, 33))
+
+        RRF, RJF, RNF>;
+>RRF : Symbol(RRF, Decl(awaitedTypeJQuery.ts, 91, 46))
+>RJF : Symbol(RJF, Decl(awaitedTypeJQuery.ts, 92, 20))
+>RNF : Symbol(RNF, Decl(awaitedTypeJQuery.ts, 92, 33))
+
+    then<ARD = never, AJD = never, AND = never,
+>then : Symbol(PromiseBase.then, Decl(awaitedTypeJQuery.ts, 8, 17), Decl(awaitedTypeJQuery.ts, 35, 59), Decl(awaitedTypeJQuery.ts, 55, 41), Decl(awaitedTypeJQuery.ts, 68, 23), Decl(awaitedTypeJQuery.ts, 88, 41) ... and 1 more)
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 102, 9))
+>AJD : Symbol(AJD, Decl(awaitedTypeJQuery.ts, 102, 21))
+>AND : Symbol(AND, Decl(awaitedTypeJQuery.ts, 102, 34))
+
+        BRD = never, BJD = never, BND = never,
+>BRD : Symbol(BRD, Decl(awaitedTypeJQuery.ts, 102, 47))
+>BJD : Symbol(BJD, Decl(awaitedTypeJQuery.ts, 103, 20))
+>BND : Symbol(BND, Decl(awaitedTypeJQuery.ts, 103, 33))
+
+        CRD = never, CJD = never, CND = never,
+>CRD : Symbol(CRD, Decl(awaitedTypeJQuery.ts, 103, 46))
+>CJD : Symbol(CJD, Decl(awaitedTypeJQuery.ts, 104, 20))
+>CND : Symbol(CND, Decl(awaitedTypeJQuery.ts, 104, 33))
+
+        RRD = never, RJD = never, RND = never>(
+>RRD : Symbol(RRD, Decl(awaitedTypeJQuery.ts, 104, 46))
+>RJD : Symbol(RJD, Decl(awaitedTypeJQuery.ts, 105, 20))
+>RND : Symbol(RND, Decl(awaitedTypeJQuery.ts, 105, 33))
+
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+>doneFilter : Symbol(doneFilter, Decl(awaitedTypeJQuery.ts, 105, 47))
+>t : Symbol(t, Decl(awaitedTypeJQuery.ts, 106, 25))
+>TR : Symbol(TR, Decl(awaitedTypeJQuery.ts, 5, 22))
+>u : Symbol(u, Decl(awaitedTypeJQuery.ts, 106, 31))
+>UR : Symbol(UR, Decl(awaitedTypeJQuery.ts, 5, 33))
+>v : Symbol(v, Decl(awaitedTypeJQuery.ts, 106, 38))
+>VR : Symbol(VR, Decl(awaitedTypeJQuery.ts, 6, 15))
+>s : Symbol(s, Decl(awaitedTypeJQuery.ts, 106, 45))
+>SR : Symbol(SR, Decl(awaitedTypeJQuery.ts, 7, 15))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 102, 9))
+>AJD : Symbol(AJD, Decl(awaitedTypeJQuery.ts, 102, 21))
+>AND : Symbol(AND, Decl(awaitedTypeJQuery.ts, 102, 34))
+
+                BRD, BJD, BND,
+>BRD : Symbol(BRD, Decl(awaitedTypeJQuery.ts, 102, 47))
+>BJD : Symbol(BJD, Decl(awaitedTypeJQuery.ts, 103, 20))
+>BND : Symbol(BND, Decl(awaitedTypeJQuery.ts, 103, 33))
+
+                CRD, CJD, CND,
+>CRD : Symbol(CRD, Decl(awaitedTypeJQuery.ts, 103, 46))
+>CJD : Symbol(CJD, Decl(awaitedTypeJQuery.ts, 104, 20))
+>CND : Symbol(CND, Decl(awaitedTypeJQuery.ts, 104, 33))
+
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+>RRD : Symbol(RRD, Decl(awaitedTypeJQuery.ts, 104, 46))
+>RJD : Symbol(RJD, Decl(awaitedTypeJQuery.ts, 105, 20))
+>RND : Symbol(RND, Decl(awaitedTypeJQuery.ts, 105, 33))
+>Thenable : Symbol(Thenable, Decl(awaitedTypeJQuery.ts, 0, 0))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 102, 9))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 102, 9))
+
+            failFilter?: null,
+>failFilter : Symbol(failFilter, Decl(awaitedTypeJQuery.ts, 109, 53))
+
+            progressFilter?: null): PromiseBase<ARD, AJD, AND,
+>progressFilter : Symbol(progressFilter, Decl(awaitedTypeJQuery.ts, 110, 30))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>ARD : Symbol(ARD, Decl(awaitedTypeJQuery.ts, 102, 9))
+>AJD : Symbol(AJD, Decl(awaitedTypeJQuery.ts, 102, 21))
+>AND : Symbol(AND, Decl(awaitedTypeJQuery.ts, 102, 34))
+
+        BRD, BJD, BND,
+>BRD : Symbol(BRD, Decl(awaitedTypeJQuery.ts, 102, 47))
+>BJD : Symbol(BJD, Decl(awaitedTypeJQuery.ts, 103, 20))
+>BND : Symbol(BND, Decl(awaitedTypeJQuery.ts, 103, 33))
+
+        CRD, CJD, CND,
+>CRD : Symbol(CRD, Decl(awaitedTypeJQuery.ts, 103, 46))
+>CJD : Symbol(CJD, Decl(awaitedTypeJQuery.ts, 104, 20))
+>CND : Symbol(CND, Decl(awaitedTypeJQuery.ts, 104, 33))
+
+        RRD, RJD, RND>;
+>RRD : Symbol(RRD, Decl(awaitedTypeJQuery.ts, 104, 46))
+>RJD : Symbol(RJD, Decl(awaitedTypeJQuery.ts, 105, 20))
+>RND : Symbol(RND, Decl(awaitedTypeJQuery.ts, 105, 33))
+}
+
+interface Promise3<TR, TJ, TN,
+>Promise3 : Symbol(Promise3, Decl(awaitedTypeJQuery.ts, 115, 1))
+>TR : Symbol(TR, Decl(awaitedTypeJQuery.ts, 117, 19))
+>TJ : Symbol(TJ, Decl(awaitedTypeJQuery.ts, 117, 22))
+>TN : Symbol(TN, Decl(awaitedTypeJQuery.ts, 117, 26))
+
+    UR, UJ, UN,
+>UR : Symbol(UR, Decl(awaitedTypeJQuery.ts, 117, 30))
+>UJ : Symbol(UJ, Decl(awaitedTypeJQuery.ts, 118, 7))
+>UN : Symbol(UN, Decl(awaitedTypeJQuery.ts, 118, 11))
+
+    VR, VJ, VN> extends PromiseBase<TR, TJ, TN,
+>VR : Symbol(VR, Decl(awaitedTypeJQuery.ts, 118, 15))
+>VJ : Symbol(VJ, Decl(awaitedTypeJQuery.ts, 119, 7))
+>VN : Symbol(VN, Decl(awaitedTypeJQuery.ts, 119, 11))
+>PromiseBase : Symbol(PromiseBase, Decl(awaitedTypeJQuery.ts, 2, 48))
+>TR : Symbol(TR, Decl(awaitedTypeJQuery.ts, 117, 19))
+>TJ : Symbol(TJ, Decl(awaitedTypeJQuery.ts, 117, 22))
+>TN : Symbol(TN, Decl(awaitedTypeJQuery.ts, 117, 26))
+
+    UR, UJ, UN,
+>UR : Symbol(UR, Decl(awaitedTypeJQuery.ts, 117, 30))
+>UJ : Symbol(UJ, Decl(awaitedTypeJQuery.ts, 118, 7))
+>UN : Symbol(UN, Decl(awaitedTypeJQuery.ts, 118, 11))
+
+    VR, VJ, VN,
+>VR : Symbol(VR, Decl(awaitedTypeJQuery.ts, 118, 15))
+>VJ : Symbol(VJ, Decl(awaitedTypeJQuery.ts, 119, 7))
+>VN : Symbol(VN, Decl(awaitedTypeJQuery.ts, 119, 11))
+
+    never, never, never> { }
+
+type T = Awaited<Promise3<string, Error, number, {}, string, boolean, any, Element, never>>; // string
+>T : Symbol(T, Decl(awaitedTypeJQuery.ts, 122, 28))
+>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --))
+>Promise3 : Symbol(Promise3, Decl(awaitedTypeJQuery.ts, 115, 1))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>Element : Symbol(Element, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --))
+
diff --git a/tests/baselines/reference/awaitedTypeJQuery.types b/tests/baselines/reference/awaitedTypeJQuery.types
new file mode 100644
index 0000000000000..365344c9ab7cc
--- /dev/null
+++ b/tests/baselines/reference/awaitedTypeJQuery.types
@@ -0,0 +1,224 @@
+=== tests/cases/compiler/awaitedTypeJQuery.ts ===
+/// <reference lib="dom" />
+
+interface Thenable<T> extends PromiseLike<T> { }
+
+// JQuery's Promise type
+interface PromiseBase<TR, TJ, TN,
+    UR, UJ, UN,
+    VR, VJ, VN,
+    SR, SJ, SN> {
+    then<ARD = never, AJD = never, AND = never,
+>then : { <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP, BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP, CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP, RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP, BRF | BRP, BJF | BJP, BNF | BNP, CRF | CRP, CJF | CJP, CNF | CNP, RRF | RRP, RJF | RJP, RNF | RNP>; <ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF, BRD | BRF, BJD | BJF, BND | BNF, CRD | CRF, CJD | CJF, CND | CNF, RRD | RRF, RJD | RJF, RND | RNF>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter?: null): PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter?: null, progressFilter?: null): PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND>; }
+
+        BRD = never, BJD = never, BND = never,
+        CRD = never, CJD = never, CND = never,
+        RRD = never, RJD = never, RND = never,
+        ARF = never, AJF = never, ANF = never,
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never,
+        ARP = never, AJP = never, ANP = never,
+        BRP = never, BJP = never, BNP = never,
+        CRP = never, CJP = never, CNP = never,
+        RRP = never, RJP = never, RNP = never>(
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+>doneFilter : (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD
+>t : TR
+>u : UR
+>v : VR
+>s : SR[]
+
+                BRD, BJD, BND,
+                CRD, CJD, CND,
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+>failFilter : (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF
+>t : TJ
+>u : UJ
+>v : VJ
+>s : SJ[]
+
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+>progressFilter : (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP
+>t : TN
+>u : UN
+>v : VN
+>s : SN[]
+
+                BRP, BJP, BNP,
+                CRP, CJP, CNP,
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
+        BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
+        CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
+        RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
+    then<ARF = never, AJF = never, ANF = never,
+>then : { <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP, BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP, CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP, RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP, BRF | BRP, BJF | BJP, BNF | BNP, CRF | CRP, CJF | CJP, CNF | CNP, RRF | RRP, RJF | RJP, RNF | RNP>; <ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF, BRD | BRF, BJD | BJF, BND | BNF, CRD | CRF, CJD | CJF, CND | CNF, RRD | RRF, RJD | RJF, RND | RNF>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter?: null): PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter?: null, progressFilter?: null): PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND>; }
+
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never,
+        ARP = never, AJP = never, ANP = never,
+        BRP = never, BJP = never, BNP = never,
+        CRP = never, CJP = never, CNP = never,
+        RRP = never, RJP = never, RNP = never>(
+            doneFilter: null,
+>doneFilter : null
+>null : null
+
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+>failFilter : (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF
+>t : TJ
+>u : UJ
+>v : VJ
+>s : SJ[]
+
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+>progressFilter : (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP
+>t : TN
+>u : UN
+>v : VN
+>s : SN[]
+
+                BRP, BJP, BNP,
+                CRP, CJP, CNP,
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
+        BRF | BRP, BJF | BJP, BNF | BNP,
+        CRF | CRP, CJF | CJP, CNF | CNP,
+        RRF | RRP, RJF | RJP, RNF | RNP>;
+    then<ARP = never, AJP = never, ANP = never,
+>then : { <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP, BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP, CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP, RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP, BRF | BRP, BJF | BJP, BNF | BNP, CRF | CRP, CJF | CJP, CNF | CNP, RRF | RRP, RJF | RJP, RNF | RNP>; <ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF, BRD | BRF, BJD | BJF, BND | BNF, CRD | CRF, CJD | CJF, CND | CNF, RRD | RRF, RJD | RJF, RND | RNF>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter?: null): PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter?: null, progressFilter?: null): PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND>; }
+
+        BRP = never, BJP = never, BNP = never,
+        CRP = never, CJP = never, CNP = never,
+        RRP = never, RJP = never, RNP = never>(
+            doneFilter: null,
+>doneFilter : null
+>null : null
+
+            failFilter: null,
+>failFilter : null
+>null : null
+
+            progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+>progressFilter : (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP
+>t : TN
+>u : UN
+>v : VN
+>s : SN[]
+
+                BRP, BJP, BNP,
+                CRP, CJP, CNP,
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
+        BRP, BJP, BNP,
+        CRP, CJP, CNP,
+        RRP, RJP, RNP>;
+    then<ARD = never, AJD = never, AND = never,
+>then : { <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP, BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP, CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP, RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP, BRF | BRP, BJF | BJP, BNF | BNP, CRF | CRP, CJF | CJP, CNF | CNP, RRF | RRP, RJF | RJP, RNF | RNP>; <ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF, BRD | BRF, BJD | BJF, BND | BNF, CRD | CRF, CJD | CJF, CND | CNF, RRD | RRF, RJD | RJF, RND | RNF>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter?: null): PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter?: null, progressFilter?: null): PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND>; }
+
+        BRD = never, BJD = never, BND = never,
+        CRD = never, CJD = never, CND = never,
+        RRD = never, RJD = never, RND = never,
+        ARF = never, AJF = never, ANF = never,
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never>(
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+>doneFilter : (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD
+>t : TR
+>u : UR
+>v : VR
+>s : SR[]
+
+                BRD, BJD, BND,
+                CRD, CJD, CND,
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+>failFilter : (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF
+>t : TJ
+>u : UJ
+>v : VJ
+>s : SJ[]
+
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
+>progressFilter : null
+>null : null
+
+        BRD | BRF, BJD | BJF, BND | BNF,
+        CRD | CRF, CJD | CJF, CND | CNF,
+        RRD | RRF, RJD | RJF, RND | RNF>;
+    then<ARF = never, AJF = never, ANF = never,
+>then : { <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP, BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP, CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP, RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP, BRF | BRP, BJF | BJP, BNF | BNP, CRF | CRP, CJF | CJP, CNF | CNP, RRF | RRP, RJF | RJP, RNF | RNP>; <ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF, BRD | BRF, BJD | BJF, BND | BNF, CRD | CRF, CJD | CJF, CND | CNF, RRD | RRF, RJD | RJF, RND | RNF>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter?: null): PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter?: null, progressFilter?: null): PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND>; }
+
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never>(
+            doneFilter: null,
+>doneFilter : null
+>null : null
+
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+>failFilter : (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF
+>t : TJ
+>u : UJ
+>v : VJ
+>s : SJ[]
+
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter?: null): PromiseBase<ARF, AJF, ANF,
+>progressFilter : null
+>null : null
+
+        BRF, BJF, BNF,
+        CRF, CJF, CNF,
+        RRF, RJF, RNF>;
+    then<ARD = never, AJD = never, AND = never,
+>then : { <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP, BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP, CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP, RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP, BRF | BRP, BJF | BJP, BNF | BNP, CRF | CRP, CJF | CJP, CNF | CNP, RRF | RRP, RJF | RJP, RNF | RNP>; <ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => ANP | PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP>): PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => ARD | PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD>, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF, BRD | BRF, BJD | BJF, BND | BNF, CRD | CRF, CJD | CJF, CND | CNF, RRD | RRF, RJD | RJF, RND | RNF>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => ARF | PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF>, progressFilter?: null): PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter?: null, progressFilter?: null): PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND>; }
+
+        BRD = never, BJD = never, BND = never,
+        CRD = never, CJD = never, CND = never,
+        RRD = never, RJD = never, RND = never>(
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+>doneFilter : (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD
+>t : TR
+>u : UR
+>v : VR
+>s : SR[]
+
+                BRD, BJD, BND,
+                CRD, CJD, CND,
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+            failFilter?: null,
+>failFilter : null
+>null : null
+
+            progressFilter?: null): PromiseBase<ARD, AJD, AND,
+>progressFilter : null
+>null : null
+
+        BRD, BJD, BND,
+        CRD, CJD, CND,
+        RRD, RJD, RND>;
+}
+
+interface Promise3<TR, TJ, TN,
+    UR, UJ, UN,
+    VR, VJ, VN> extends PromiseBase<TR, TJ, TN,
+    UR, UJ, UN,
+    VR, VJ, VN,
+    never, never, never> { }
+
+type T = Awaited<Promise3<string, Error, number, {}, string, boolean, any, Element, never>>; // string
+>T : string
+
diff --git a/tests/baselines/reference/classStaticBlock23(target=es2022).symbols b/tests/baselines/reference/classStaticBlock23(target=es2022).symbols
index 2e15bade3be31..bbe48c4520b70 100644
--- a/tests/baselines/reference/classStaticBlock23(target=es2022).symbols
+++ b/tests/baselines/reference/classStaticBlock23(target=es2022).symbols
@@ -4,9 +4,9 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
 >[1, 2, 3].map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >n : Symbol(n, Decl(classStaticBlock23.ts, 0, 27))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >n : Symbol(n, Decl(classStaticBlock23.ts, 0, 27))
 
 class C {
diff --git a/tests/baselines/reference/classStaticBlock23(target=es2022).types b/tests/baselines/reference/classStaticBlock23(target=es2022).types
index 421336fa087c9..f7d3d60be78ec 100644
--- a/tests/baselines/reference/classStaticBlock23(target=es2022).types
+++ b/tests/baselines/reference/classStaticBlock23(target=es2022).types
@@ -11,9 +11,9 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
 >n => Promise.resolve(n) : (n: number) => Promise<number>
 >n : number
 >Promise.resolve(n) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >n : number
 
 class C {
diff --git a/tests/baselines/reference/classStaticBlock23(target=esnext).symbols b/tests/baselines/reference/classStaticBlock23(target=esnext).symbols
index 2e15bade3be31..bbe48c4520b70 100644
--- a/tests/baselines/reference/classStaticBlock23(target=esnext).symbols
+++ b/tests/baselines/reference/classStaticBlock23(target=esnext).symbols
@@ -4,9 +4,9 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
 >[1, 2, 3].map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >n : Symbol(n, Decl(classStaticBlock23.ts, 0, 27))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >n : Symbol(n, Decl(classStaticBlock23.ts, 0, 27))
 
 class C {
diff --git a/tests/baselines/reference/classStaticBlock23(target=esnext).types b/tests/baselines/reference/classStaticBlock23(target=esnext).types
index 421336fa087c9..f7d3d60be78ec 100644
--- a/tests/baselines/reference/classStaticBlock23(target=esnext).types
+++ b/tests/baselines/reference/classStaticBlock23(target=esnext).types
@@ -11,9 +11,9 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
 >n => Promise.resolve(n) : (n: number) => Promise<number>
 >n : number
 >Promise.resolve(n) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >n : number
 
 class C {
diff --git a/tests/baselines/reference/es5-asyncFunctionLongObjectLiteral.symbols b/tests/baselines/reference/es5-asyncFunctionLongObjectLiteral.symbols
index 3a1ba97483e66..1d2e17fe41010 100644
--- a/tests/baselines/reference/es5-asyncFunctionLongObjectLiteral.symbols
+++ b/tests/baselines/reference/es5-asyncFunctionLongObjectLiteral.symbols
@@ -7,33 +7,33 @@ const fooShort = async () => {
     return {
         a: await Promise.resolve(0),
 >a : Symbol(a, Decl(es5-asyncFunctionLongObjectLiteral.ts, 3, 12))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         b: await Promise.resolve(1),
 >b : Symbol(b, Decl(es5-asyncFunctionLongObjectLiteral.ts, 4, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         c: await Promise.resolve(2),
 >c : Symbol(c, Decl(es5-asyncFunctionLongObjectLiteral.ts, 5, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         d: await Promise.resolve(3),
 >d : Symbol(d, Decl(es5-asyncFunctionLongObjectLiteral.ts, 6, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         e: await Promise.resolve(4),
 >e : Symbol(e, Decl(es5-asyncFunctionLongObjectLiteral.ts, 7, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     };
 }
@@ -44,63 +44,63 @@ const fooLong = async () => {
     return {
         a: await Promise.resolve(0),
 >a : Symbol(a, Decl(es5-asyncFunctionLongObjectLiteral.ts, 13, 12))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         b: await Promise.resolve(1),
 >b : Symbol(b, Decl(es5-asyncFunctionLongObjectLiteral.ts, 14, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         c: await Promise.resolve(2),
 >c : Symbol(c, Decl(es5-asyncFunctionLongObjectLiteral.ts, 15, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         d: await Promise.resolve(3),
 >d : Symbol(d, Decl(es5-asyncFunctionLongObjectLiteral.ts, 16, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         e: await Promise.resolve(4),
 >e : Symbol(e, Decl(es5-asyncFunctionLongObjectLiteral.ts, 17, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         f: await Promise.resolve(5),
 >f : Symbol(f, Decl(es5-asyncFunctionLongObjectLiteral.ts, 18, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         g: await Promise.resolve(6),
 >g : Symbol(g, Decl(es5-asyncFunctionLongObjectLiteral.ts, 19, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         h: await Promise.resolve(7),
 >h : Symbol(h, Decl(es5-asyncFunctionLongObjectLiteral.ts, 20, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         i: await Promise.resolve(8),
 >i : Symbol(i, Decl(es5-asyncFunctionLongObjectLiteral.ts, 21, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
         j: await Promise.resolve(9),
 >j : Symbol(j, Decl(es5-asyncFunctionLongObjectLiteral.ts, 22, 36))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     };
 }
diff --git a/tests/baselines/reference/es5-asyncFunctionLongObjectLiteral.types b/tests/baselines/reference/es5-asyncFunctionLongObjectLiteral.types
index cd05ad7f3e965..734fe02ab5935 100644
--- a/tests/baselines/reference/es5-asyncFunctionLongObjectLiteral.types
+++ b/tests/baselines/reference/es5-asyncFunctionLongObjectLiteral.types
@@ -12,45 +12,45 @@ const fooShort = async () => {
 >a : number
 >await Promise.resolve(0) : number
 >Promise.resolve(0) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >0 : 0
 
         b: await Promise.resolve(1),
 >b : number
 >await Promise.resolve(1) : number
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
         c: await Promise.resolve(2),
 >c : number
 >await Promise.resolve(2) : number
 >Promise.resolve(2) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >2 : 2
 
         d: await Promise.resolve(3),
 >d : number
 >await Promise.resolve(3) : number
 >Promise.resolve(3) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >3 : 3
 
         e: await Promise.resolve(4),
 >e : number
 >await Promise.resolve(4) : number
 >Promise.resolve(4) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >4 : 4
 
     };
@@ -67,90 +67,90 @@ const fooLong = async () => {
 >a : number
 >await Promise.resolve(0) : number
 >Promise.resolve(0) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >0 : 0
 
         b: await Promise.resolve(1),
 >b : number
 >await Promise.resolve(1) : number
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
         c: await Promise.resolve(2),
 >c : number
 >await Promise.resolve(2) : number
 >Promise.resolve(2) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >2 : 2
 
         d: await Promise.resolve(3),
 >d : number
 >await Promise.resolve(3) : number
 >Promise.resolve(3) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >3 : 3
 
         e: await Promise.resolve(4),
 >e : number
 >await Promise.resolve(4) : number
 >Promise.resolve(4) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >4 : 4
 
         f: await Promise.resolve(5),
 >f : number
 >await Promise.resolve(5) : number
 >Promise.resolve(5) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >5 : 5
 
         g: await Promise.resolve(6),
 >g : number
 >await Promise.resolve(6) : number
 >Promise.resolve(6) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >6 : 6
 
         h: await Promise.resolve(7),
 >h : number
 >await Promise.resolve(7) : number
 >Promise.resolve(7) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >7 : 7
 
         i: await Promise.resolve(8),
 >i : number
 >await Promise.resolve(8) : number
 >Promise.resolve(8) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >8 : 8
 
         j: await Promise.resolve(9),
 >j : number
 >await Promise.resolve(9) : number
 >Promise.resolve(9) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >9 : 9
 
     };
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.symbols b/tests/baselines/reference/exportDefaultAsyncFunction2.symbols
index 44ef20cd83227..ac2034bcf53da 100644
--- a/tests/baselines/reference/exportDefaultAsyncFunction2.symbols
+++ b/tests/baselines/reference/exportDefaultAsyncFunction2.symbols
@@ -16,9 +16,9 @@ import { async, await } from 'asyncawait';
 export default async(() => await(Promise.resolve(1)));
 >async : Symbol(async, Decl(a.ts, 0, 8))
 >await : Symbol(await, Decl(a.ts, 0, 15))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 === tests/cases/compiler/b.ts ===
 export default async () => { return 0; };
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.types b/tests/baselines/reference/exportDefaultAsyncFunction2.types
index 4a3a20286db70..a1daedde5cc46 100644
--- a/tests/baselines/reference/exportDefaultAsyncFunction2.types
+++ b/tests/baselines/reference/exportDefaultAsyncFunction2.types
@@ -19,9 +19,9 @@ export default async(() => await(Promise.resolve(1)));
 >await(Promise.resolve(1)) : any
 >await : (...args: any[]) => any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 === tests/cases/compiler/b.ts ===
diff --git a/tests/baselines/reference/generatorReturnContextualType.symbols b/tests/baselines/reference/generatorReturnContextualType.symbols
index 15dce2efcd67b..fca92ce78630b 100644
--- a/tests/baselines/reference/generatorReturnContextualType.symbols
+++ b/tests/baselines/reference/generatorReturnContextualType.symbols
@@ -25,9 +25,9 @@ async function* f3(): AsyncGenerator<any, { x: 'x' }, any> {
 >x : Symbol(x, Decl(generatorReturnContextualType.ts, 10, 43))
 
   return Promise.resolve({ x: 'x' });
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >x : Symbol(x, Decl(generatorReturnContextualType.ts, 11, 26))
 }
 
@@ -41,9 +41,9 @@ async function* f4(): AsyncGenerator<any, { x: 'x' }, any> {
 >x : Symbol(x, Decl(generatorReturnContextualType.ts, 15, 15))
 
   return Promise.resolve(ret); // Error
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >ret : Symbol(ret, Decl(generatorReturnContextualType.ts, 15, 7))
 }
 
diff --git a/tests/baselines/reference/generatorReturnContextualType.types b/tests/baselines/reference/generatorReturnContextualType.types
index 4731414abb876..17360297fb27a 100644
--- a/tests/baselines/reference/generatorReturnContextualType.types
+++ b/tests/baselines/reference/generatorReturnContextualType.types
@@ -27,9 +27,9 @@ async function* f3(): AsyncGenerator<any, { x: 'x' }, any> {
 
   return Promise.resolve({ x: 'x' });
 >Promise.resolve({ x: 'x' }) : Promise<{ x: "x"; }>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >{ x: 'x' } : { x: "x"; }
 >x : "x"
 >'x' : "x"
@@ -47,9 +47,9 @@ async function* f4(): AsyncGenerator<any, { x: 'x' }, any> {
 
   return Promise.resolve(ret); // Error
 >Promise.resolve(ret) : Promise<{ x: string; }>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >ret : { x: string; }
 }
 
diff --git a/tests/baselines/reference/genericFunctionInference1.symbols b/tests/baselines/reference/genericFunctionInference1.symbols
index 0c2881bb1ce62..b192a4a36a87e 100644
--- a/tests/baselines/reference/genericFunctionInference1.symbols
+++ b/tests/baselines/reference/genericFunctionInference1.symbols
@@ -921,9 +921,9 @@ const fn30: Fn = pipe(
 
 const promise = Promise.resolve(1);
 >promise : Symbol(promise, Decl(genericFunctionInference1.ts, 194, 5))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 promise.then(
 >promise.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
diff --git a/tests/baselines/reference/genericFunctionInference1.types b/tests/baselines/reference/genericFunctionInference1.types
index 9dd28cea1a72e..f8d6971304268 100644
--- a/tests/baselines/reference/genericFunctionInference1.types
+++ b/tests/baselines/reference/genericFunctionInference1.types
@@ -835,9 +835,9 @@ const fn30: Fn = pipe(
 const promise = Promise.resolve(1);
 >promise : Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 promise.then(
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols
index 099c5761978d6..b48d3cf8a1eeb 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols
@@ -6,9 +6,9 @@ function truePromise(): Promise<true> {
 >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, --, --))
 
     return Promise.resolve(true);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 
 interface Wrap<T> {
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
index dc1d4b32e9b45..b7406b782ec94 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
@@ -7,9 +7,9 @@ function truePromise(): Promise<true> {
 
     return Promise.resolve(true);
 >Promise.resolve(true) : Promise<true>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >true : true
 }
 
diff --git a/tests/baselines/reference/instantiateContextualTypes.symbols b/tests/baselines/reference/instantiateContextualTypes.symbols
index d3e8a7a317c4f..2952526b0f8a3 100644
--- a/tests/baselines/reference/instantiateContextualTypes.symbols
+++ b/tests/baselines/reference/instantiateContextualTypes.symbols
@@ -422,9 +422,9 @@ class Interesting {
 
 		return Promise.resolve().then(() => {
 >Promise.resolve().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 
 			if (1 < 2) {
@@ -440,9 +440,9 @@ class Interesting {
 
 		return Promise.resolve().then(() => {
 >Promise.resolve().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 
 			return 'ELSE';
@@ -455,9 +455,9 @@ class Interesting {
 
 		return Promise.resolve().then(() => {
 >Promise.resolve().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 
 			if (1 < 2) {
diff --git a/tests/baselines/reference/instantiateContextualTypes.types b/tests/baselines/reference/instantiateContextualTypes.types
index 72ea90d59533e..18a4a81875f37 100644
--- a/tests/baselines/reference/instantiateContextualTypes.types
+++ b/tests/baselines/reference/instantiateContextualTypes.types
@@ -342,9 +342,9 @@ class Interesting {
 >Promise.resolve().then(() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'ELSE';		}) : Promise<"SOMETHING" | "ELSE">
 >Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'ELSE';		} : () => "SOMETHING" | "ELSE"
 
@@ -369,9 +369,9 @@ class Interesting {
 >Promise.resolve().then(() => {			return 'ELSE';		}) : Promise<"SOMETHING" | "ELSE">
 >Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => {			return 'ELSE';		} : () => "ELSE"
 
@@ -388,9 +388,9 @@ class Interesting {
 >Promise.resolve().then(() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'SOMETHING';		}) : Promise<"SOMETHING" | "ELSE">
 >Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'SOMETHING';		} : () => "SOMETHING"
 
diff --git a/tests/baselines/reference/intersectionWithConflictingPrivates.symbols b/tests/baselines/reference/intersectionWithConflictingPrivates.symbols
index a59fe008c244b..45823fe2ba044 100644
--- a/tests/baselines/reference/intersectionWithConflictingPrivates.symbols
+++ b/tests/baselines/reference/intersectionWithConflictingPrivates.symbols
@@ -132,9 +132,9 @@ class Foo {
 >options : Symbol(options, Decl(intersectionWithConflictingPrivates.ts, 52, 92))
 
     return Promise.resolve(undefined);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >undefined : Symbol(undefined)
   }
 }
diff --git a/tests/baselines/reference/intersectionWithConflictingPrivates.types b/tests/baselines/reference/intersectionWithConflictingPrivates.types
index d7f8e4a9dedaa..88b5d864fd125 100644
--- a/tests/baselines/reference/intersectionWithConflictingPrivates.types
+++ b/tests/baselines/reference/intersectionWithConflictingPrivates.types
@@ -144,9 +144,9 @@ class Foo {
 
     return Promise.resolve(undefined);
 >Promise.resolve(undefined) : Promise<undefined>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >undefined : undefined
   }
 }
diff --git a/tests/baselines/reference/jsDeclarationsJSDocRedirectedLookups.symbols b/tests/baselines/reference/jsDeclarationsJSDocRedirectedLookups.symbols
index b24b2964a493b..ac28461de26d7 100644
--- a/tests/baselines/reference/jsDeclarationsJSDocRedirectedLookups.symbols
+++ b/tests/baselines/reference/jsDeclarationsJSDocRedirectedLookups.symbols
@@ -31,9 +31,9 @@
 
 /** @type {promise} */const j = Promise.resolve(0);
 >j : Symbol(j, Decl(index.js, 11, 27))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 /** @type {Object<string, string>} */const k = {x: "x"};
 >k : Symbol(k, Decl(index.js, 12, 42))
diff --git a/tests/baselines/reference/jsDeclarationsJSDocRedirectedLookups.types b/tests/baselines/reference/jsDeclarationsJSDocRedirectedLookups.types
index f86bca410ef66..a31abbb13db9f 100644
--- a/tests/baselines/reference/jsDeclarationsJSDocRedirectedLookups.types
+++ b/tests/baselines/reference/jsDeclarationsJSDocRedirectedLookups.types
@@ -43,9 +43,9 @@
 /** @type {promise} */const j = Promise.resolve(0);
 >j : Promise<any>
 >Promise.resolve(0) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >0 : 0
 
 /** @type {Object<string, string>} */const k = {x: "x"};
diff --git a/tests/baselines/reference/jsFileCompilationAwaitModifier.symbols b/tests/baselines/reference/jsFileCompilationAwaitModifier.symbols
index dc54056d75649..4148f9b391c21 100644
--- a/tests/baselines/reference/jsFileCompilationAwaitModifier.symbols
+++ b/tests/baselines/reference/jsFileCompilationAwaitModifier.symbols
@@ -6,18 +6,18 @@ class Foo {
 >a : Symbol(Foo.a, Decl(a.js, 0, 11))
 
         await Promise.resolve(1);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
     }
 
     b = async () => {
 >b : Symbol(Foo.b, Decl(a.js, 3, 5))
 
         await Promise.resolve(1);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
     }
 }
 
diff --git a/tests/baselines/reference/jsFileCompilationAwaitModifier.types b/tests/baselines/reference/jsFileCompilationAwaitModifier.types
index 3cbc18ccbd10b..36fd99b086415 100644
--- a/tests/baselines/reference/jsFileCompilationAwaitModifier.types
+++ b/tests/baselines/reference/jsFileCompilationAwaitModifier.types
@@ -8,9 +8,9 @@ class Foo {
         await Promise.resolve(1);
 >await Promise.resolve(1) : number
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
     }
 
@@ -21,9 +21,9 @@ class Foo {
         await Promise.resolve(1);
 >await Promise.resolve(1) : number
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
     }
 }
diff --git a/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.symbols b/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.symbols
index d7e26e854aa71..70f95bf5a69dc 100644
--- a/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.symbols
+++ b/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.symbols
@@ -22,16 +22,16 @@ function returnAnyArray(arr) {
 /** @type {Promise} */
 var anyPromise = Promise.resolve(5);
 >anyPromise : Symbol(anyPromise, Decl(jsdocArrayObjectPromiseImplicitAny.js, 15, 3))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 /** @type {Promise<number>} */
 var numberPromise = Promise.resolve(5);
 >numberPromise : Symbol(numberPromise, Decl(jsdocArrayObjectPromiseImplicitAny.js, 18, 3))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 /**
  * @param {Promise} pr
diff --git a/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.types b/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.types
index 3e7a475d66aee..114f4384aaec7 100644
--- a/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.types
+++ b/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.types
@@ -27,18 +27,18 @@ function returnAnyArray(arr) {
 var anyPromise = Promise.resolve(5);
 >anyPromise : Promise<any>
 >Promise.resolve(5) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >5 : 5
 
 /** @type {Promise<number>} */
 var numberPromise = Promise.resolve(5);
 >numberPromise : Promise<number>
 >Promise.resolve(5) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >5 : 5
 
 /**
diff --git a/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.symbols b/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.symbols
index b46584a20aed5..f4475a19ef402 100644
--- a/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.symbols
+++ b/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.symbols
@@ -22,16 +22,16 @@ function returnNotAnyArray(arr) {
 /** @type {Promise} */
 var notAnyPromise = Promise.resolve(5);
 >notAnyPromise : Symbol(notAnyPromise, Decl(jsdocArrayObjectPromiseNoImplicitAny.js, 15, 3))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 /** @type {Promise<number>} */
 var numberPromise = Promise.resolve(5);
 >numberPromise : Symbol(numberPromise, Decl(jsdocArrayObjectPromiseNoImplicitAny.js, 18, 3))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 /**
  * @param {Promise} pr
diff --git a/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.types b/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.types
index 875f56ad9ca59..950b482c72b19 100644
--- a/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.types
+++ b/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.types
@@ -27,18 +27,18 @@ function returnNotAnyArray(arr) {
 var notAnyPromise = Promise.resolve(5);
 >notAnyPromise : Promise<any>
 >Promise.resolve(5) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >5 : 5
 
 /** @type {Promise<number>} */
 var numberPromise = Promise.resolve(5);
 >numberPromise : Promise<number>
 >Promise.resolve(5) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >5 : 5
 
 /**
diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.symbols b/tests/baselines/reference/noImplicitReturnsInAsync1.symbols
index fbcd727d0d67c..fe225cb508cdb 100644
--- a/tests/baselines/reference/noImplicitReturnsInAsync1.symbols
+++ b/tests/baselines/reference/noImplicitReturnsInAsync1.symbols
@@ -10,7 +10,7 @@ async function test(isError: boolean = false) {
     }
     let x = await Promise.resolve("The test is passed without an error.");
 >x : Symbol(x, Decl(noImplicitReturnsInAsync1.ts, 4, 7))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.types b/tests/baselines/reference/noImplicitReturnsInAsync1.types
index d6ae47e213ff7..de9b95cdb4912 100644
--- a/tests/baselines/reference/noImplicitReturnsInAsync1.types
+++ b/tests/baselines/reference/noImplicitReturnsInAsync1.types
@@ -15,8 +15,8 @@ async function test(isError: boolean = false) {
 >x : string
 >await Promise.resolve("The test is passed without an error.") : string
 >Promise.resolve("The test is passed without an error.") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"The test is passed without an error." : "The test is passed without an error."
 }
diff --git a/tests/baselines/reference/privateNameMethodAsync.symbols b/tests/baselines/reference/privateNameMethodAsync.symbols
index f3c70cb19eda7..6503c07c589c6 100644
--- a/tests/baselines/reference/privateNameMethodAsync.symbols
+++ b/tests/baselines/reference/privateNameMethodAsync.symbols
@@ -4,9 +4,9 @@ const C = class {
 
     async #bar() { return await Promise.resolve(42); }
 >#bar : Symbol(C.#bar, Decl(privateNameMethodAsync.ts, 0, 17))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     async foo() {
 >foo : Symbol(C.foo, Decl(privateNameMethodAsync.ts, 1, 54))
@@ -38,9 +38,9 @@ const C = class {
 >#qux : Symbol(C.#qux, Decl(privateNameMethodAsync.ts, 6, 25))
 
         yield (await Promise.resolve(42));
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
     }
 }
 
diff --git a/tests/baselines/reference/privateNameMethodAsync.types b/tests/baselines/reference/privateNameMethodAsync.types
index 3ac547af0404c..cab18ac600e20 100644
--- a/tests/baselines/reference/privateNameMethodAsync.types
+++ b/tests/baselines/reference/privateNameMethodAsync.types
@@ -7,9 +7,9 @@ const C = class {
 >#bar : () => Promise<number>
 >await Promise.resolve(42) : number
 >Promise.resolve(42) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >42 : 42
 
     async foo() {
@@ -64,9 +64,9 @@ const C = class {
 >(await Promise.resolve(42)) : number
 >await Promise.resolve(42) : number
 >Promise.resolve(42) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >42 : 42
     }
 }
diff --git a/tests/baselines/reference/privateNameStaticMethodAsync.symbols b/tests/baselines/reference/privateNameStaticMethodAsync.symbols
index 0e13961283a06..238e2f1ede477 100644
--- a/tests/baselines/reference/privateNameStaticMethodAsync.symbols
+++ b/tests/baselines/reference/privateNameStaticMethodAsync.symbols
@@ -4,9 +4,9 @@ const C = class {
 
     static async #bar() { return await Promise.resolve(42); }
 >#bar : Symbol(C.#bar, Decl(privateNameStaticMethodAsync.ts, 0, 17))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     static async foo() {
 >foo : Symbol(C.foo, Decl(privateNameStaticMethodAsync.ts, 1, 61))
@@ -38,9 +38,9 @@ const C = class {
 >#qux : Symbol(C.#qux, Decl(privateNameStaticMethodAsync.ts, 6, 32))
 
         yield (await Promise.resolve(42));
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
     }
     async static *#bazBad() { yield 42; }
 >#bazBad : Symbol(C.#bazBad, Decl(privateNameStaticMethodAsync.ts, 9, 5))
diff --git a/tests/baselines/reference/privateNameStaticMethodAsync.types b/tests/baselines/reference/privateNameStaticMethodAsync.types
index 6da52fd602fc2..b9250cdd0468e 100644
--- a/tests/baselines/reference/privateNameStaticMethodAsync.types
+++ b/tests/baselines/reference/privateNameStaticMethodAsync.types
@@ -7,9 +7,9 @@ const C = class {
 >#bar : () => Promise<number>
 >await Promise.resolve(42) : number
 >Promise.resolve(42) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >42 : 42
 
     static async foo() {
@@ -64,9 +64,9 @@ const C = class {
 >(await Promise.resolve(42)) : number
 >await Promise.resolve(42) : number
 >Promise.resolve(42) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >42 : 42
     }
     async static *#bazBad() { yield 42; }
diff --git a/tests/baselines/reference/promiseType.js b/tests/baselines/reference/promiseType.js
index 84d9d713b4810..457e5e93d73b1 100644
--- a/tests/baselines/reference/promiseType.js
+++ b/tests/baselines/reference/promiseType.js
@@ -217,7 +217,12 @@ 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));
-
+
+Promise.resolve(undefined as Promise<string> | number);
+Promise.resolve(undefined as Promise<Promise<number>>);
+Promise.resolve(undefined as string | Promise<Promise<number>>);
+Promise.resolve(undefined as Promise<string> | Promise<Promise<number>>);
+Promise.resolve(undefined as Promise<string | Promise<Promise<number>>>);
 
 //// [promiseType.js]
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -440,3 +445,8 @@ 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));
+Promise.resolve(undefined);
+Promise.resolve(undefined);
+Promise.resolve(undefined);
+Promise.resolve(undefined);
+Promise.resolve(undefined);
diff --git a/tests/baselines/reference/promiseType.symbols b/tests/baselines/reference/promiseType.symbols
index cec81cd7d8266..e1ff0a75aa012 100644
--- a/tests/baselines/reference/promiseType.symbols
+++ b/tests/baselines/reference/promiseType.symbols
@@ -236,9 +236,9 @@ const p19 = p.catch(() => Promise.resolve(1));
 >p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p20 = p.then(undefined);
 >p20 : Symbol(p20, Decl(promiseType.ts, 98, 5))
@@ -296,9 +296,9 @@ const p28 = p.then(() => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p29 = p.then(() => Promise.reject(1));
 >p29 : Symbol(p29, Decl(promiseType.ts, 107, 5))
@@ -374,9 +374,9 @@ const p38 = p.then(undefined, () => Promise.resolve(1));
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p39 = p.then(undefined, () => Promise.reject(1));
 >p39 : Symbol(p39, Decl(promiseType.ts, 118, 5))
@@ -444,9 +444,9 @@ const p48 = p.then(null, () => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p49 = p.then(null, () => Promise.reject(1));
 >p49 : Symbol(p49, Decl(promiseType.ts, 129, 5))
@@ -513,9 +513,9 @@ const p58 = p.then(() => "1", () => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p59 = p.then(() => "1", () => Promise.reject(1));
 >p59 : Symbol(p59, Decl(promiseType.ts, 140, 5))
@@ -591,9 +591,9 @@ const p68 = p.then(() => x, () => Promise.resolve(1));
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p69 = p.then(() => x, () => Promise.reject(1));
 >p69 : Symbol(p69, Decl(promiseType.ts, 151, 5))
@@ -670,9 +670,9 @@ const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p79 = p.then(() => undefined, () => Promise.reject(1));
 >p79 : Symbol(p79, Decl(promiseType.ts, 162, 5))
@@ -740,9 +740,9 @@ const p88 = p.then(() => null, () => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p89 = p.then(() => null, () => Promise.reject(1));
 >p89 : Symbol(p89, Decl(promiseType.ts, 173, 5))
@@ -809,9 +809,9 @@ const p98 = p.then(() => {}, () => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p99 = p.then(() => {}, () => Promise.reject(1));
 >p99 : Symbol(p99, Decl(promiseType.ts, 184, 5))
@@ -878,9 +878,9 @@ const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
 >pa9 : Symbol(pa9, Decl(promiseType.ts, 195, 5))
@@ -896,9 +896,9 @@ const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pb1 = p.then(() => Promise.resolve("1"), null);
@@ -906,27 +906,27 @@ const pb1 = p.then(() => Promise.resolve("1"), null);
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >pb2 : Symbol(pb2, Decl(promiseType.ts, 199, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >pb3 : Symbol(pb3, Decl(promiseType.ts, 200, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >x : Symbol(x, Decl(promiseType.ts, 1, 11))
 
 const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
@@ -934,9 +934,9 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pb5 = p.then(() => Promise.resolve("1"), () => null);
@@ -944,48 +944,48 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >pb6 : Symbol(pb6, Decl(promiseType.ts, 203, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >pb7 : Symbol(pb7, Decl(promiseType.ts, 204, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >pb8 : Symbol(pb8, Decl(promiseType.ts, 205, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >pb9 : Symbol(pb9, Decl(promiseType.ts, 206, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, 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, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --))
@@ -1073,9 +1073,9 @@ const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >Promise.reject : Symbol(PromiseConstructor.reject, 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, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >pc9 : Symbol(pc9, Decl(promiseType.ts, 217, 5))
@@ -1089,3 +1089,44 @@ 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, --, --))
 
+Promise.resolve(undefined as Promise<string> | number);
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), 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<Promise<number>>);
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), 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 : 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 string | Promise<Promise<number>>);
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), 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 : 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<string> | Promise<Promise<number>>);
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), 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 : 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.resolve(undefined as Promise<string | Promise<Promise<number>>>);
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), 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 : 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, --, --))
+
diff --git a/tests/baselines/reference/promiseType.types b/tests/baselines/reference/promiseType.types
index c459a02d36b13..eee55b46129cd 100644
--- a/tests/baselines/reference/promiseType.types
+++ b/tests/baselines/reference/promiseType.types
@@ -283,9 +283,9 @@ const p19 = p.catch(() => Promise.resolve(1));
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p20 = p.then(undefined);
@@ -365,9 +365,9 @@ const p28 = p.then(() => Promise.resolve(1));
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p29 = p.then(() => Promise.reject(1));
@@ -469,9 +469,9 @@ const p38 = p.then(undefined, () => Promise.resolve(1));
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p39 = p.then(undefined, () => Promise.reject(1));
@@ -574,9 +574,9 @@ const p48 = p.then(null, () => Promise.resolve(1));
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p49 = p.then(null, () => Promise.reject(1));
@@ -688,9 +688,9 @@ const p58 = p.then(() => "1", () => Promise.resolve(1));
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p59 = p.then(() => "1", () => Promise.reject(1));
@@ -803,9 +803,9 @@ const p68 = p.then(() => x, () => Promise.resolve(1));
 >x : any
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p69 = p.then(() => x, () => Promise.reject(1));
@@ -918,9 +918,9 @@ const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p79 = p.then(() => undefined, () => Promise.reject(1));
@@ -1033,9 +1033,9 @@ const p88 = p.then(() => null, () => Promise.resolve(1));
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p89 = p.then(() => null, () => Promise.reject(1));
@@ -1139,9 +1139,9 @@ const p98 = p.then(() => {}, () => Promise.resolve(1));
 >() => {} : () => void
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p99 = p.then(() => {}, () => Promise.reject(1));
@@ -1253,9 +1253,9 @@ const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >1 : 1
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
@@ -1281,9 +1281,9 @@ const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >undefined : undefined
 
@@ -1295,9 +1295,9 @@ const pb1 = p.then(() => Promise.resolve("1"), null);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >null : null
 
@@ -1309,9 +1309,9 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1324,9 +1324,9 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1339,9 +1339,9 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => undefined : () => any
 >undefined : undefined
@@ -1354,9 +1354,9 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => null : () => any
 >null : null
@@ -1369,9 +1369,9 @@ const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => {} : () => void
 
@@ -1383,9 +1383,9 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1398,15 +1398,15 @@ const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
@@ -1417,9 +1417,9 @@ const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
@@ -1559,9 +1559,9 @@ const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
@@ -1583,3 +1583,43 @@ const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >reject : <T = never>(reason?: any) => Promise<T>
 >1 : 1
 
+Promise.resolve(undefined as Promise<string> | number);
+>Promise.resolve(undefined as Promise<string> | number) : Promise<string | number>
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
+>Promise : PromiseConstructor
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
+>undefined as Promise<string> | number : number | Promise<string>
+>undefined : undefined
+
+Promise.resolve(undefined as Promise<Promise<number>>);
+>Promise.resolve(undefined as Promise<Promise<number>>) : Promise<number>
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
+>Promise : PromiseConstructor
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
+>undefined as Promise<Promise<number>> : Promise<Promise<number>>
+>undefined : undefined
+
+Promise.resolve(undefined as string | Promise<Promise<number>>);
+>Promise.resolve(undefined as string | Promise<Promise<number>>) : Promise<string | number>
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
+>Promise : PromiseConstructor
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
+>undefined as string | Promise<Promise<number>> : string | Promise<Promise<number>>
+>undefined : undefined
+
+Promise.resolve(undefined as Promise<string> | Promise<Promise<number>>);
+>Promise.resolve(undefined as Promise<string> | Promise<Promise<number>>) : Promise<string | number>
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
+>Promise : PromiseConstructor
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
+>undefined as Promise<string> | Promise<Promise<number>> : Promise<string> | Promise<Promise<number>>
+>undefined : undefined
+
+Promise.resolve(undefined as Promise<string | Promise<Promise<number>>>);
+>Promise.resolve(undefined as Promise<string | Promise<Promise<number>>>) : Promise<string | number>
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
+>Promise : PromiseConstructor
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
+>undefined as Promise<string | Promise<Promise<number>>> : Promise<string | Promise<Promise<number>>>
+>undefined : undefined
+
diff --git a/tests/baselines/reference/promiseTypeStrictNull.symbols b/tests/baselines/reference/promiseTypeStrictNull.symbols
index 4f95974eab589..a81e0a408b291 100644
--- a/tests/baselines/reference/promiseTypeStrictNull.symbols
+++ b/tests/baselines/reference/promiseTypeStrictNull.symbols
@@ -236,9 +236,9 @@ const p19 = p.catch(() => Promise.resolve(1));
 >p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p20 = p.then(undefined);
 >p20 : Symbol(p20, Decl(promiseTypeStrictNull.ts, 98, 5))
@@ -296,9 +296,9 @@ const p28 = p.then(() => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p29 = p.then(() => Promise.reject(1));
 >p29 : Symbol(p29, Decl(promiseTypeStrictNull.ts, 107, 5))
@@ -374,9 +374,9 @@ const p38 = p.then(undefined, () => Promise.resolve(1));
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p39 = p.then(undefined, () => Promise.reject(1));
 >p39 : Symbol(p39, Decl(promiseTypeStrictNull.ts, 118, 5))
@@ -444,9 +444,9 @@ const p48 = p.then(null, () => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p49 = p.then(null, () => Promise.reject(1));
 >p49 : Symbol(p49, Decl(promiseTypeStrictNull.ts, 129, 5))
@@ -513,9 +513,9 @@ const p58 = p.then(() => "1", () => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p59 = p.then(() => "1", () => Promise.reject(1));
 >p59 : Symbol(p59, Decl(promiseTypeStrictNull.ts, 140, 5))
@@ -591,9 +591,9 @@ const p68 = p.then(() => x, () => Promise.resolve(1));
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p69 = p.then(() => x, () => Promise.reject(1));
 >p69 : Symbol(p69, Decl(promiseTypeStrictNull.ts, 151, 5))
@@ -670,9 +670,9 @@ const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p79 = p.then(() => undefined, () => Promise.reject(1));
 >p79 : Symbol(p79, Decl(promiseTypeStrictNull.ts, 162, 5))
@@ -740,9 +740,9 @@ const p88 = p.then(() => null, () => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p89 = p.then(() => null, () => Promise.reject(1));
 >p89 : Symbol(p89, Decl(promiseTypeStrictNull.ts, 173, 5))
@@ -809,9 +809,9 @@ const p98 = p.then(() => {}, () => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p99 = p.then(() => {}, () => Promise.reject(1));
 >p99 : Symbol(p99, Decl(promiseTypeStrictNull.ts, 184, 5))
@@ -878,9 +878,9 @@ const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
 >pa9 : Symbol(pa9, Decl(promiseTypeStrictNull.ts, 195, 5))
@@ -896,9 +896,9 @@ const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pb1 = p.then(() => Promise.resolve("1"), null);
@@ -906,27 +906,27 @@ const pb1 = p.then(() => Promise.resolve("1"), null);
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >pb2 : Symbol(pb2, Decl(promiseTypeStrictNull.ts, 199, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >pb3 : Symbol(pb3, Decl(promiseTypeStrictNull.ts, 200, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >x : Symbol(x, Decl(promiseTypeStrictNull.ts, 1, 11))
 
 const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
@@ -934,9 +934,9 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const pb5 = p.then(() => Promise.resolve("1"), () => null);
@@ -944,48 +944,48 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >pb6 : Symbol(pb6, Decl(promiseTypeStrictNull.ts, 203, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >pb7 : Symbol(pb7, Decl(promiseTypeStrictNull.ts, 204, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >pb8 : Symbol(pb8, Decl(promiseTypeStrictNull.ts, 205, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >pb9 : Symbol(pb9, Decl(promiseTypeStrictNull.ts, 206, 5))
 >p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, 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, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --))
@@ -1073,9 +1073,9 @@ const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >Promise.reject : Symbol(PromiseConstructor.reject, 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, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >pc9 : Symbol(pc9, Decl(promiseTypeStrictNull.ts, 217, 5))
diff --git a/tests/baselines/reference/promiseTypeStrictNull.types b/tests/baselines/reference/promiseTypeStrictNull.types
index 97038aeb4e533..44912749c0e91 100644
--- a/tests/baselines/reference/promiseTypeStrictNull.types
+++ b/tests/baselines/reference/promiseTypeStrictNull.types
@@ -283,9 +283,9 @@ const p19 = p.catch(() => Promise.resolve(1));
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p20 = p.then(undefined);
@@ -365,9 +365,9 @@ const p28 = p.then(() => Promise.resolve(1));
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p29 = p.then(() => Promise.reject(1));
@@ -469,9 +469,9 @@ const p38 = p.then(undefined, () => Promise.resolve(1));
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p39 = p.then(undefined, () => Promise.reject(1));
@@ -574,9 +574,9 @@ const p48 = p.then(null, () => Promise.resolve(1));
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p49 = p.then(null, () => Promise.reject(1));
@@ -688,9 +688,9 @@ const p58 = p.then(() => "1", () => Promise.resolve(1));
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p59 = p.then(() => "1", () => Promise.reject(1));
@@ -803,9 +803,9 @@ const p68 = p.then(() => x, () => Promise.resolve(1));
 >x : any
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p69 = p.then(() => x, () => Promise.reject(1));
@@ -918,9 +918,9 @@ const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p79 = p.then(() => undefined, () => Promise.reject(1));
@@ -1033,9 +1033,9 @@ const p88 = p.then(() => null, () => Promise.resolve(1));
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p89 = p.then(() => null, () => Promise.reject(1));
@@ -1139,9 +1139,9 @@ const p98 = p.then(() => {}, () => Promise.resolve(1));
 >() => {} : () => void
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const p99 = p.then(() => {}, () => Promise.reject(1));
@@ -1253,9 +1253,9 @@ const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >1 : 1
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
@@ -1281,9 +1281,9 @@ const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >undefined : undefined
 
@@ -1295,9 +1295,9 @@ const pb1 = p.then(() => Promise.resolve("1"), null);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >null : null
 
@@ -1309,9 +1309,9 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1324,9 +1324,9 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1339,9 +1339,9 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => undefined : () => undefined
 >undefined : undefined
@@ -1354,9 +1354,9 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => null : () => null
 >null : null
@@ -1369,9 +1369,9 @@ const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => {} : () => void
 
@@ -1383,9 +1383,9 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1398,15 +1398,15 @@ const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
@@ -1417,9 +1417,9 @@ const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
@@ -1559,9 +1559,9 @@ const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols
index e431bbd4a1968..8cdee3c1d63b1 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.symbols
+++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols
@@ -26,9 +26,9 @@ function f1(): Promise<T1> {
 >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0))
 
     return Promise.resolve({ __t1: "foo_t1" });
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28))
 }
 
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.types b/tests/baselines/reference/promiseVoidErrorCallback.types
index b7539cdbf1d89..5fadc187b92bf 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.types
+++ b/tests/baselines/reference/promiseVoidErrorCallback.types
@@ -19,9 +19,9 @@ function f1(): Promise<T1> {
 
     return Promise.resolve({ __t1: "foo_t1" });
 >Promise.resolve({ __t1: "foo_t1" }) : Promise<{ __t1: string; }>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >{ __t1: "foo_t1" } : { __t1: string; }
 >__t1 : string
 >"foo_t1" : "foo_t1"
diff --git a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).symbols b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).symbols
index 29020fceb3acf..1f089db0d0431 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).symbols
@@ -129,9 +129,9 @@ export { _await as await };
 // for-await-of
 const arr = [Promise.resolve()];
 >arr : Symbol(arr, Decl(other.ts, 6, 5))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 for await (const item of arr) {
 >item : Symbol(item, Decl(other.ts, 8, 16))
diff --git a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).types b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).types
index c3d2a0c0a9bb5..6501c2788bf8d 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).types
+++ b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2015).types
@@ -181,9 +181,9 @@ const arr = [Promise.resolve()];
 >arr : Promise<void>[]
 >[Promise.resolve()] : Promise<void>[]
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 
 for await (const item of arr) {
 >item : void
diff --git a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).symbols b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).symbols
index 29020fceb3acf..1f089db0d0431 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).symbols
@@ -129,9 +129,9 @@ export { _await as await };
 // for-await-of
 const arr = [Promise.resolve()];
 >arr : Symbol(arr, Decl(other.ts, 6, 5))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 for await (const item of arr) {
 >item : Symbol(item, Decl(other.ts, 8, 16))
diff --git a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).types b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).types
index c3d2a0c0a9bb5..6501c2788bf8d 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).types
+++ b/tests/baselines/reference/topLevelAwait.1(module=es2022,target=es2017).types
@@ -181,9 +181,9 @@ const arr = [Promise.resolve()];
 >arr : Promise<void>[]
 >[Promise.resolve()] : Promise<void>[]
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 
 for await (const item of arr) {
 >item : void
diff --git a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).symbols b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).symbols
index 29020fceb3acf..1f089db0d0431 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).symbols
@@ -129,9 +129,9 @@ export { _await as await };
 // for-await-of
 const arr = [Promise.resolve()];
 >arr : Symbol(arr, Decl(other.ts, 6, 5))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 for await (const item of arr) {
 >item : Symbol(item, Decl(other.ts, 8, 16))
diff --git a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).types b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).types
index c3d2a0c0a9bb5..6501c2788bf8d 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).types
+++ b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2015).types
@@ -181,9 +181,9 @@ const arr = [Promise.resolve()];
 >arr : Promise<void>[]
 >[Promise.resolve()] : Promise<void>[]
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 
 for await (const item of arr) {
 >item : void
diff --git a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).symbols b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).symbols
index 29020fceb3acf..1f089db0d0431 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).symbols
@@ -129,9 +129,9 @@ export { _await as await };
 // for-await-of
 const arr = [Promise.resolve()];
 >arr : Symbol(arr, Decl(other.ts, 6, 5))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 for await (const item of arr) {
 >item : Symbol(item, Decl(other.ts, 8, 16))
diff --git a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).types b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).types
index c3d2a0c0a9bb5..6501c2788bf8d 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).types
+++ b/tests/baselines/reference/topLevelAwait.1(module=esnext,target=es2017).types
@@ -181,9 +181,9 @@ const arr = [Promise.resolve()];
 >arr : Promise<void>[]
 >[Promise.resolve()] : Promise<void>[]
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 
 for await (const item of arr) {
 >item : void
diff --git a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).symbols b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).symbols
index 29020fceb3acf..1f089db0d0431 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).symbols
@@ -129,9 +129,9 @@ export { _await as await };
 // for-await-of
 const arr = [Promise.resolve()];
 >arr : Symbol(arr, Decl(other.ts, 6, 5))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 for await (const item of arr) {
 >item : Symbol(item, Decl(other.ts, 8, 16))
diff --git a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).types b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).types
index c3d2a0c0a9bb5..6501c2788bf8d 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).types
+++ b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2015).types
@@ -181,9 +181,9 @@ const arr = [Promise.resolve()];
 >arr : Promise<void>[]
 >[Promise.resolve()] : Promise<void>[]
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 
 for await (const item of arr) {
 >item : void
diff --git a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).symbols b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).symbols
index 29020fceb3acf..1f089db0d0431 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).symbols
+++ b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).symbols
@@ -129,9 +129,9 @@ export { _await as await };
 // for-await-of
 const arr = [Promise.resolve()];
 >arr : Symbol(arr, Decl(other.ts, 6, 5))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 for await (const item of arr) {
 >item : Symbol(item, Decl(other.ts, 8, 16))
diff --git a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).types b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).types
index c3d2a0c0a9bb5..6501c2788bf8d 100644
--- a/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).types
+++ b/tests/baselines/reference/topLevelAwait.1(module=system,target=es2017).types
@@ -181,9 +181,9 @@ const arr = [Promise.resolve()];
 >arr : Promise<void>[]
 >[Promise.resolve()] : Promise<void>[]
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 
 for await (const item of arr) {
 >item : void
diff --git a/tests/baselines/reference/topLevelAwaitNonModule(module=es2022).symbols b/tests/baselines/reference/topLevelAwaitNonModule(module=es2022).symbols
index 2e6a266f51ac8..0983572ac45a8 100644
--- a/tests/baselines/reference/topLevelAwaitNonModule(module=es2022).symbols
+++ b/tests/baselines/reference/topLevelAwaitNonModule(module=es2022).symbols
@@ -3,9 +3,9 @@ await x;
 
 const arr = [Promise.resolve()];
 >arr : Symbol(arr, Decl(topLevelAwaitNonModule.ts, 2, 5))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 for await (const item of arr) {
 >item : Symbol(item, Decl(topLevelAwaitNonModule.ts, 4, 16))
diff --git a/tests/baselines/reference/topLevelAwaitNonModule(module=es2022).types b/tests/baselines/reference/topLevelAwaitNonModule(module=es2022).types
index a6d2b7ed32c07..5c9951cd16f94 100644
--- a/tests/baselines/reference/topLevelAwaitNonModule(module=es2022).types
+++ b/tests/baselines/reference/topLevelAwaitNonModule(module=es2022).types
@@ -7,9 +7,9 @@ const arr = [Promise.resolve()];
 >arr : Promise<void>[]
 >[Promise.resolve()] : Promise<void>[]
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 
 for await (const item of arr) {
 >item : void
diff --git a/tests/baselines/reference/topLevelAwaitNonModule(module=esnext).symbols b/tests/baselines/reference/topLevelAwaitNonModule(module=esnext).symbols
index 2e6a266f51ac8..0983572ac45a8 100644
--- a/tests/baselines/reference/topLevelAwaitNonModule(module=esnext).symbols
+++ b/tests/baselines/reference/topLevelAwaitNonModule(module=esnext).symbols
@@ -3,9 +3,9 @@ await x;
 
 const arr = [Promise.resolve()];
 >arr : Symbol(arr, Decl(topLevelAwaitNonModule.ts, 2, 5))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 for await (const item of arr) {
 >item : Symbol(item, Decl(topLevelAwaitNonModule.ts, 4, 16))
diff --git a/tests/baselines/reference/topLevelAwaitNonModule(module=esnext).types b/tests/baselines/reference/topLevelAwaitNonModule(module=esnext).types
index a6d2b7ed32c07..5c9951cd16f94 100644
--- a/tests/baselines/reference/topLevelAwaitNonModule(module=esnext).types
+++ b/tests/baselines/reference/topLevelAwaitNonModule(module=esnext).types
@@ -7,9 +7,9 @@ const arr = [Promise.resolve()];
 >arr : Promise<void>[]
 >[Promise.resolve()] : Promise<void>[]
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 
 for await (const item of arr) {
 >item : void
diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols b/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols
index e13cce398aba3..6afc1b15bad6d 100644
--- a/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols
+++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols
@@ -15,9 +15,9 @@ async function a(): Bluebird<void> {
 
       try {
         await Bluebird.resolve(); // -- remove this and it compiles
->Bluebird.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Bluebird.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Bluebird : Symbol(Bluebird, Decl(main.ts, 1, 6))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
       } catch (error) { }
 >error : Symbol(error, Decl(main.ts, 7, 15))
diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.types b/tests/baselines/reference/transformNestedGeneratorsWithTry.types
index cc6b2288391c0..f3b214d81f152 100644
--- a/tests/baselines/reference/transformNestedGeneratorsWithTry.types
+++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.types
@@ -16,9 +16,9 @@ async function a(): Bluebird<void> {
         await Bluebird.resolve(); // -- remove this and it compiles
 >await Bluebird.resolve() : void
 >Bluebird.resolve() : Promise<void>
->Bluebird.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Bluebird.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Bluebird : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 
       } catch (error) { }
 >error : any
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.1.symbols b/tests/baselines/reference/types.asyncGenerators.es2018.1.symbols
index 5cf681477e586..a7e0aa9830818 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.1.symbols
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.1.symbols
@@ -16,18 +16,18 @@ async function * inferReturnType4() {
 >inferReturnType4 : Symbol(inferReturnType4, Decl(types.asyncGenerators.es2018.1.ts, 7, 1))
 
     yield Promise.resolve(1);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 async function * inferReturnType5() {
 >inferReturnType5 : Symbol(inferReturnType5, Decl(types.asyncGenerators.es2018.1.ts, 10, 1))
 
     yield 1;
     yield Promise.resolve(2);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 async function * inferReturnType6() {
 >inferReturnType6 : Symbol(inferReturnType6, Decl(types.asyncGenerators.es2018.1.ts, 14, 1))
@@ -38,9 +38,9 @@ async function * inferReturnType7() {
 >inferReturnType7 : Symbol(inferReturnType7, Decl(types.asyncGenerators.es2018.1.ts, 17, 1))
 
     yield* [Promise.resolve(1)];
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 async function * inferReturnType8() {
 >inferReturnType8 : Symbol(inferReturnType8, Decl(types.asyncGenerators.es2018.1.ts, 20, 1))
@@ -58,9 +58,9 @@ const assignability2: () => AsyncIterableIterator<number> = async function * ()
 >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 };
 const assignability3: () => AsyncIterableIterator<number> = async function * () {
@@ -74,9 +74,9 @@ const assignability4: () => AsyncIterableIterator<number> = async function * ()
 >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 };
 const assignability5: () => AsyncIterableIterator<number> = async function * () {
@@ -96,9 +96,9 @@ const assignability7: () => AsyncIterable<number> = async function * () {
 >AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 };
 const assignability8: () => AsyncIterable<number> = async function * () {
@@ -112,9 +112,9 @@ const assignability9: () => AsyncIterable<number> = async function * () {
 >AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 };
 const assignability10: () => AsyncIterable<number> = async function * () {
@@ -134,9 +134,9 @@ const assignability12: () => AsyncIterator<number> = async function * () {
 >AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 };
 const assignability13: () => AsyncIterator<number> = async function * () {
@@ -150,9 +150,9 @@ const assignability14: () => AsyncIterator<number> = async function * () {
 >AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 };
 const assignability15: () => AsyncIterator<number> = async function * () {
@@ -172,9 +172,9 @@ async function * explicitReturnType2(): AsyncIterableIterator<number> {
 >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 async function * explicitReturnType3(): AsyncIterableIterator<number> {
 >explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.es2018.1.ts, 74, 1))
@@ -187,9 +187,9 @@ async function * explicitReturnType4(): AsyncIterableIterator<number> {
 >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 async function * explicitReturnType5(): AsyncIterableIterator<number> {
 >explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.es2018.1.ts, 80, 1))
@@ -208,9 +208,9 @@ async function * explicitReturnType7(): AsyncIterable<number> {
 >AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 async function * explicitReturnType8(): AsyncIterable<number> {
 >explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.es2018.1.ts, 89, 1))
@@ -223,9 +223,9 @@ async function * explicitReturnType9(): AsyncIterable<number> {
 >AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 async function * explicitReturnType10(): AsyncIterable<number> {
 >explicitReturnType10 : Symbol(explicitReturnType10, Decl(types.asyncGenerators.es2018.1.ts, 95, 1))
@@ -244,9 +244,9 @@ async function * explicitReturnType12(): AsyncIterator<number> {
 >AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 async function * explicitReturnType13(): AsyncIterator<number> {
 >explicitReturnType13 : Symbol(explicitReturnType13, Decl(types.asyncGenerators.es2018.1.ts, 104, 1))
@@ -259,9 +259,9 @@ async function * explicitReturnType14(): AsyncIterator<number> {
 >AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 async function * explicitReturnType15(): AsyncIterator<number> {
 >explicitReturnType15 : Symbol(explicitReturnType15, Decl(types.asyncGenerators.es2018.1.ts, 110, 1))
@@ -285,9 +285,9 @@ async function * awaitedType2() {
 
     const x = await Promise.resolve(1);
 >x : Symbol(x, Decl(types.asyncGenerators.es2018.1.ts, 121, 9))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 async function * nextType1(): { next(...args: [] | [number | PromiseLike<number>]): any } {
 >nextType1 : Symbol(nextType1, Decl(types.asyncGenerators.es2018.1.ts, 122, 1))
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.1.types b/tests/baselines/reference/types.asyncGenerators.es2018.1.types
index 10f961da0a2bf..db0c35b27c84b 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.1.types
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.1.types
@@ -21,9 +21,9 @@ async function * inferReturnType4() {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 }
 async function * inferReturnType5() {
@@ -36,9 +36,9 @@ async function * inferReturnType5() {
     yield Promise.resolve(2);
 >yield Promise.resolve(2) : any
 >Promise.resolve(2) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >2 : 2
 }
 async function * inferReturnType6() {
@@ -57,9 +57,9 @@ async function * inferReturnType7() {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 }
 async function * inferReturnType8() {
@@ -89,9 +89,9 @@ const assignability2: () => AsyncIterableIterator<number> = async function * ()
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 };
@@ -114,9 +114,9 @@ const assignability4: () => AsyncIterableIterator<number> = async function * ()
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 };
@@ -149,9 +149,9 @@ const assignability7: () => AsyncIterable<number> = async function * () {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 };
@@ -174,9 +174,9 @@ const assignability9: () => AsyncIterable<number> = async function * () {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 };
@@ -209,9 +209,9 @@ const assignability12: () => AsyncIterator<number> = async function * () {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 };
@@ -234,9 +234,9 @@ const assignability14: () => AsyncIterator<number> = async function * () {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 
 };
@@ -266,9 +266,9 @@ async function * explicitReturnType2(): AsyncIterableIterator<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 }
 async function * explicitReturnType3(): AsyncIterableIterator<number> {
@@ -287,9 +287,9 @@ async function * explicitReturnType4(): AsyncIterableIterator<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 }
 async function * explicitReturnType5(): AsyncIterableIterator<number> {
@@ -316,9 +316,9 @@ async function * explicitReturnType7(): AsyncIterable<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 }
 async function * explicitReturnType8(): AsyncIterable<number> {
@@ -337,9 +337,9 @@ async function * explicitReturnType9(): AsyncIterable<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 }
 async function * explicitReturnType10(): AsyncIterable<number> {
@@ -366,9 +366,9 @@ async function * explicitReturnType12(): AsyncIterator<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 }
 async function * explicitReturnType13(): AsyncIterator<number> {
@@ -387,9 +387,9 @@ async function * explicitReturnType14(): AsyncIterator<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 }
 async function * explicitReturnType15(): AsyncIterator<number> {
@@ -425,9 +425,9 @@ async function * awaitedType2() {
 >x : number
 >await Promise.resolve(1) : number
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >1 : 1
 }
 async function * nextType1(): { next(...args: [] | [number | PromiseLike<number>]): any } {
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.symbols b/tests/baselines/reference/types.asyncGenerators.es2018.2.symbols
index 830a4774131d7..78d8cc65a1575 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.2.symbols
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.symbols
@@ -14,9 +14,9 @@ async function * inferReturnType3() {
 >inferReturnType3 : Symbol(inferReturnType3, Decl(types.asyncGenerators.es2018.2.ts, 5, 1))
 
     yield* Promise.resolve([1, 2]);
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
 const assignability1: () => AsyncIterableIterator<number> = async function * () {
 >assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.es2018.2.ts, 9, 5))
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.types b/tests/baselines/reference/types.asyncGenerators.es2018.2.types
index 15e7936ba6351..9a2326662fd13 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.2.types
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.types
@@ -20,9 +20,9 @@ async function * inferReturnType3() {
     yield* Promise.resolve([1, 2]);
 >yield* Promise.resolve([1, 2]) : any
 >Promise.resolve([1, 2]) : Promise<number[]>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >[1, 2] : number[]
 >1 : 1
 >2 : 2
diff --git a/tests/baselines/reference/unionAndIntersectionInference1.symbols b/tests/baselines/reference/unionAndIntersectionInference1.symbols
index 9b4e7244cfd98..815e70ddce106 100644
--- a/tests/baselines/reference/unionAndIntersectionInference1.symbols
+++ b/tests/baselines/reference/unionAndIntersectionInference1.symbols
@@ -215,9 +215,9 @@ const createTestAsync = (): Promise<ITest> => Promise.resolve().then(() => ({ na
 >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, --, --))
 >ITest : Symbol(ITest, Decl(unionAndIntersectionInference1.ts, 71, 18))
 >Promise.resolve().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
 >name : Symbol(name, Decl(unionAndIntersectionInference1.ts, 79, 77))
 
diff --git a/tests/baselines/reference/unionAndIntersectionInference1.types b/tests/baselines/reference/unionAndIntersectionInference1.types
index 51683684f2a57..ec56cbbd1c4ac 100644
--- a/tests/baselines/reference/unionAndIntersectionInference1.types
+++ b/tests/baselines/reference/unionAndIntersectionInference1.types
@@ -192,9 +192,9 @@ const createTestAsync = (): Promise<ITest> => Promise.resolve().then(() => ({ na
 >Promise.resolve().then(() => ({ name: 'test' })) : Promise<ITest | { name: "test"; }>
 >Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >Promise.resolve() : Promise<void>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => ({ name: 'test' }) : () => { name: "test"; }
 >({ name: 'test' }) : { name: "test"; }
diff --git a/tests/baselines/reference/uniqueSymbols.symbols b/tests/baselines/reference/uniqueSymbols.symbols
index 2df23f1fc95f4..6b75247727afd 100644
--- a/tests/baselines/reference/uniqueSymbols.symbols
+++ b/tests/baselines/reference/uniqueSymbols.symbols
@@ -392,9 +392,9 @@ const constInitToLReadonlyNestedTypeWithIndexedAccess: L["nested"]["readonlyNest
 // type argument inference
 const promiseForConstCall = Promise.resolve(constCall);
 >promiseForConstCall : Symbol(promiseForConstCall, Decl(uniqueSymbols.ts, 115, 5))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >constCall : Symbol(constCall, Decl(uniqueSymbols.ts, 1, 5))
 
 const arrayOfConstCall = [constCall];
diff --git a/tests/baselines/reference/uniqueSymbols.types b/tests/baselines/reference/uniqueSymbols.types
index aa956c4045ca8..55b9da33dfe79 100644
--- a/tests/baselines/reference/uniqueSymbols.types
+++ b/tests/baselines/reference/uniqueSymbols.types
@@ -400,9 +400,9 @@ const constInitToLReadonlyNestedTypeWithIndexedAccess: L["nested"]["readonlyNest
 const promiseForConstCall = Promise.resolve(constCall);
 >promiseForConstCall : Promise<unique symbol>
 >Promise.resolve(constCall) : Promise<unique symbol>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >constCall : unique symbol
 
 const arrayOfConstCall = [constCall];
diff --git a/tests/baselines/reference/uniqueSymbolsDeclarations.symbols b/tests/baselines/reference/uniqueSymbolsDeclarations.symbols
index 56024cf1cfb8b..8a79338129ba0 100644
--- a/tests/baselines/reference/uniqueSymbolsDeclarations.symbols
+++ b/tests/baselines/reference/uniqueSymbolsDeclarations.symbols
@@ -387,9 +387,9 @@ const constInitToLReadonlyNestedTypeWithIndexedAccess: L["nested"]["readonlyNest
 // type argument inference
 const promiseForConstCall = Promise.resolve(constCall);
 >promiseForConstCall : Symbol(promiseForConstCall, Decl(uniqueSymbolsDeclarations.ts, 111, 5))
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), 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, --, --), Decl(lib.es2018.promise.d.ts, --, --))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >constCall : Symbol(constCall, Decl(uniqueSymbolsDeclarations.ts, 1, 5))
 
 const arrayOfConstCall = [constCall];
diff --git a/tests/baselines/reference/uniqueSymbolsDeclarations.types b/tests/baselines/reference/uniqueSymbolsDeclarations.types
index 018b6d50ad79c..596ac0fb81cf7 100644
--- a/tests/baselines/reference/uniqueSymbolsDeclarations.types
+++ b/tests/baselines/reference/uniqueSymbolsDeclarations.types
@@ -393,9 +393,9 @@ const constInitToLReadonlyNestedTypeWithIndexedAccess: L["nested"]["readonlyNest
 const promiseForConstCall = Promise.resolve(constCall);
 >promiseForConstCall : Promise<unique symbol>
 >Promise.resolve(constCall) : Promise<unique symbol>
->Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >Promise : PromiseConstructor
->resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
+>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >constCall : unique symbol
 
 const arrayOfConstCall = [constCall];
diff --git a/tests/baselines/reference/user/fp-ts.log b/tests/baselines/reference/user/fp-ts.log
new file mode 100644
index 0000000000000..202a60ba3dd17
--- /dev/null
+++ b/tests/baselines/reference/user/fp-ts.log
@@ -0,0 +1,12 @@
+Exit Code: 1
+Standard output:
+src/Task.ts(90,16): error TS2322: Type 'Promise<A extends PromiseLike<infer U> ? U : A>' is not assignable to type 'Promise<A>'.
+  Type 'A extends PromiseLike<infer U> ? U : A' is not assignable to type 'A'.
+    Type 'unknown' is not assignable to type 'A'.
+src/Task.ts(99,16): error TS2322: Type 'Promise<A extends PromiseLike<infer U> ? U : A>' is not assignable to type 'Promise<A>'.
+  Type 'A extends PromiseLike<infer U> ? U : A' is not assignable to type 'A'.
+    Type 'unknown' is not assignable to type 'A'.
+
+
+
+Standard error:
diff --git a/tests/cases/compiler/awaitedTypeJQuery.ts b/tests/cases/compiler/awaitedTypeJQuery.ts
new file mode 100644
index 0000000000000..a477b7719e4da
--- /dev/null
+++ b/tests/cases/compiler/awaitedTypeJQuery.ts
@@ -0,0 +1,125 @@
+/// <reference lib="dom" />
+
+interface Thenable<T> extends PromiseLike<T> { }
+
+// JQuery's Promise type
+interface PromiseBase<TR, TJ, TN,
+    UR, UJ, UN,
+    VR, VJ, VN,
+    SR, SJ, SN> {
+    then<ARD = never, AJD = never, AND = never,
+        BRD = never, BJD = never, BND = never,
+        CRD = never, CJD = never, CND = never,
+        RRD = never, RJD = never, RND = never,
+        ARF = never, AJF = never, ANF = never,
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never,
+        ARP = never, AJP = never, ANP = never,
+        BRP = never, BJP = never, BNP = never,
+        CRP = never, CJP = never, CNP = never,
+        RRP = never, RJP = never, RNP = never>(
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                BRD, BJD, BND,
+                CRD, CJD, CND,
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                BRP, BJP, BNP,
+                CRP, CJP, CNP,
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP,
+        BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP,
+        CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP,
+        RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
+    then<ARF = never, AJF = never, ANF = never,
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never,
+        ARP = never, AJP = never, ANP = never,
+        BRP = never, BJP = never, BNP = never,
+        CRP = never, CJP = never, CNP = never,
+        RRP = never, RJP = never, RNP = never>(
+            doneFilter: null,
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                BRP, BJP, BNP,
+                CRP, CJP, CNP,
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP,
+        BRF | BRP, BJF | BJP, BNF | BNP,
+        CRF | CRP, CJF | CJP, CNF | CNP,
+        RRF | RRP, RJF | RJP, RNF | RNP>;
+    then<ARP = never, AJP = never, ANP = never,
+        BRP = never, BJP = never, BNP = never,
+        CRP = never, CJP = never, CNP = never,
+        RRP = never, RJP = never, RNP = never>(
+            doneFilter: null,
+            failFilter: null,
+            progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP,
+                BRP, BJP, BNP,
+                CRP, CJP, CNP,
+                RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP,
+        BRP, BJP, BNP,
+        CRP, CJP, CNP,
+        RRP, RJP, RNP>;
+    then<ARD = never, AJD = never, AND = never,
+        BRD = never, BJD = never, BND = never,
+        CRD = never, CJD = never, CND = never,
+        RRD = never, RJD = never, RND = never,
+        ARF = never, AJF = never, ANF = never,
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never>(
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                BRD, BJD, BND,
+                CRD, CJD, CND,
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF,
+        BRD | BRF, BJD | BJF, BND | BNF,
+        CRD | CRF, CJD | CJF, CND | CNF,
+        RRD | RRF, RJD | RJF, RND | RNF>;
+    then<ARF = never, AJF = never, ANF = never,
+        BRF = never, BJF = never, BNF = never,
+        CRF = never, CJF = never, CNF = never,
+        RRF = never, RJF = never, RNF = never>(
+            doneFilter: null,
+            failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF,
+                BRF, BJF, BNF,
+                CRF, CJF, CNF,
+                RRF, RJF, RNF> | Thenable<ARF> | ARF,
+            progressFilter?: null): PromiseBase<ARF, AJF, ANF,
+        BRF, BJF, BNF,
+        CRF, CJF, CNF,
+        RRF, RJF, RNF>;
+    then<ARD = never, AJD = never, AND = never,
+        BRD = never, BJD = never, BND = never,
+        CRD = never, CJD = never, CND = never,
+        RRD = never, RJD = never, RND = never>(
+            doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND,
+                BRD, BJD, BND,
+                CRD, CJD, CND,
+                RRD, RJD, RND> | Thenable<ARD> | ARD,
+            failFilter?: null,
+            progressFilter?: null): PromiseBase<ARD, AJD, AND,
+        BRD, BJD, BND,
+        CRD, CJD, CND,
+        RRD, RJD, RND>;
+}
+
+interface Promise3<TR, TJ, TN,
+    UR, UJ, UN,
+    VR, VJ, VN> extends PromiseBase<TR, TJ, TN,
+    UR, UJ, UN,
+    VR, VJ, VN,
+    never, never, never> { }
+
+type T = Awaited<Promise3<string, Error, number, {}, string, boolean, any, Element, never>>; // string
\ No newline at end of file
diff --git a/tests/cases/compiler/promiseType.ts b/tests/cases/compiler/promiseType.ts
index ba4a7f6041396..a61f9bcc65431 100644
--- a/tests/cases/compiler/promiseType.ts
+++ b/tests/cases/compiler/promiseType.ts
@@ -217,3 +217,9 @@ 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));
+
+Promise.resolve(undefined as Promise<string> | number);
+Promise.resolve(undefined as Promise<Promise<number>>);
+Promise.resolve(undefined as string | Promise<Promise<number>>);
+Promise.resolve(undefined as Promise<string> | Promise<Promise<number>>);
+Promise.resolve(undefined as Promise<string | Promise<Promise<number>>>);
\ No newline at end of file