diff --git a/Gulpfile.ts b/Gulpfile.ts
index 4a03557270f89..2031157f61c5f 100644
--- a/Gulpfile.ts
+++ b/Gulpfile.ts
@@ -1066,7 +1066,7 @@ gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are:
     const fileMatcher = cmdLineOptions["files"];
     const files = fileMatcher
         ? `src/**/${fileMatcher}`
-        : "Gulpfile.ts 'scripts/tslint/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts'";
+        : "Gulpfile.ts 'scripts/tslint/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts' --exclude 'src/lib/es2015.iterable.d.ts' --exclude 'src/lib/es2015.promise.d.ts'";
     const cmd = `node node_modules/tslint/bin/tslint ${files} --format stylish`;
     console.log("Linting: " + cmd);
     child_process.execSync(cmd, { stdio: [0, 1, 2] });
diff --git a/Jakefile.js b/Jakefile.js
index b3e18e8cb1a3d..b8fe2015c9333 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -1208,7 +1208,7 @@ task("lint", ["build-rules"], () => {
     const fileMatcher = process.env.f || process.env.file || process.env.files;
     const files = fileMatcher
         ? `src/**/${fileMatcher}`
-        : "Gulpfile.ts 'scripts/tslint/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts'";
+        : "Gulpfile.ts 'scripts/tslint/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts' --exclude 'src/lib/es2015.iterable.d.ts' --exclude 'src/lib/es2015.promise.d.ts'";
     const cmd = `node node_modules/tslint/bin/tslint ${files} --format stylish`;
     console.log("Linting: " + cmd);
     jake.exec([cmd], { interactive: true }, () => {
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 4405a31db28f7..a1dc4653c90f2 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -315,6 +315,7 @@ namespace ts {
         let deferredGlobalESSymbolType: ObjectType;
         let deferredGlobalTypedPropertyDescriptorType: GenericType;
         let deferredGlobalPromiseType: GenericType;
+        let deferredGlobalPromiseLikeType: GenericType;
         let deferredGlobalPromiseConstructorSymbol: Symbol;
         let deferredGlobalPromiseConstructorLikeType: ObjectType;
         let deferredGlobalIterableType: GenericType;
@@ -355,7 +356,7 @@ namespace ts {
         const visitedFlowTypes: FlowType[] = [];
         const potentialThisCollisions: Node[] = [];
         const potentialNewTargetCollisions: Node[] = [];
-        const awaitedTypeStack: number[] = [];
+        const awaitedTypeStack: Type[] = [];
 
         const diagnostics = createDiagnosticCollection();
 
@@ -2529,13 +2530,18 @@ namespace ts {
                 if (type.flags & TypeFlags.Index) {
                     const indexedType = (<IndexType>type).type;
                     const indexTypeNode = typeToTypeNodeHelper(indexedType, context);
-                    return createTypeOperatorNode(indexTypeNode);
+                    return createTypeOperatorNode(indexTypeNode, SyntaxKind.KeyOfKeyword);
                 }
                 if (type.flags & TypeFlags.IndexedAccess) {
                     const objectTypeNode = typeToTypeNodeHelper((<IndexedAccessType>type).objectType, context);
                     const indexTypeNode = typeToTypeNodeHelper((<IndexedAccessType>type).indexType, context);
                     return createIndexedAccessTypeNode(objectTypeNode, indexTypeNode);
                 }
+                if (type.flags & TypeFlags.Awaited) {
+                    const indexedType = (<AwaitedType>type).type;
+                    const indexTypeNode = typeToTypeNodeHelper(indexedType, context);
+                    return createTypeOperatorNode(indexTypeNode, SyntaxKind.AwaitedKeyword);
+                }
 
                 Debug.fail("Should be unreachable.");
 
@@ -3305,6 +3311,17 @@ namespace ts {
                         writeType((<IndexedAccessType>type).indexType, TypeFormatFlags.None);
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                     }
+                    else if (type.flags & TypeFlags.Awaited) {
+                        if (flags & TypeFormatFlags.InElementType) {
+                            writePunctuation(writer, SyntaxKind.OpenParenToken);
+                        }
+                        writer.writeKeyword("awaited");
+                        writeSpace(writer);
+                        writeType((<AwaitedType>type).type, TypeFormatFlags.InElementType);
+                        if (flags & TypeFormatFlags.InElementType) {
+                            writePunctuation(writer, SyntaxKind.CloseParenToken);
+                        }
+                    }
                     else {
                         // Should never get here
                         // { ... }
@@ -5711,7 +5728,8 @@ namespace ts {
             const modifiersType = getApparentType(getModifiersTypeFromMappedType(type)); // The 'T' in 'keyof T'
             const templateReadonly = !!type.declaration.readonlyToken;
             const templateOptional = !!type.declaration.questionToken;
-            if (type.declaration.typeParameter.constraint.kind === SyntaxKind.TypeOperator) {
+            const constraintDeclaration = type.declaration.typeParameter.constraint;
+            if (constraintDeclaration.kind === SyntaxKind.TypeOperator && (<TypeOperatorNode>constraintDeclaration).operator === SyntaxKind.KeyOfKeyword) {
                 // We have a { [P in keyof T]: X }
                 for (const propertySymbol of getPropertiesOfType(modifiersType)) {
                     addMemberForKeyType(getLiteralTypeFromPropertyName(propertySymbol), propertySymbol);
@@ -5786,7 +5804,7 @@ namespace ts {
         function getModifiersTypeFromMappedType(type: MappedType) {
             if (!type.modifiersType) {
                 const constraintDeclaration = type.declaration.typeParameter.constraint;
-                if (constraintDeclaration.kind === SyntaxKind.TypeOperator) {
+                if (constraintDeclaration.kind === SyntaxKind.TypeOperator && (<TypeOperatorNode>constraintDeclaration).operator === SyntaxKind.KeyOfKeyword) {
                     // If the constraint declaration is a 'keyof T' node, the modifiers type is T. We check
                     // AST nodes here because, when T is a non-generic type, the logic below eagerly resolves
                     // 'keyof T' to a literal union type and we can't recover T from that type.
@@ -6006,6 +6024,10 @@ namespace ts {
                     const baseIndexedAccess = baseObjectType && baseIndexType ? getIndexedAccessType(baseObjectType, baseIndexType) : undefined;
                     return baseIndexedAccess && baseIndexedAccess !== unknownType ? getBaseConstraint(baseIndexedAccess) : undefined;
                 }
+                if (t.flags & TypeFlags.Awaited) {
+                    const basePromiseType = getBaseConstraint((<AwaitedType>t).type);
+                    return basePromiseType ? getAwaitedType(basePromiseType) : undefined;
+                }
                 if (isGenericMappedType(t)) {
                     return emptyObjectType;
                 }
@@ -7074,6 +7096,10 @@ namespace ts {
             return deferredGlobalPromiseType || (deferredGlobalPromiseType = getGlobalType("Promise" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType;
         }
 
+        function getGlobalPromiseLikeType(reportErrors: boolean) {
+            return deferredGlobalPromiseLikeType || (deferredGlobalPromiseLikeType = getGlobalType("PromiseLike" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType;
+        }
+
         function getGlobalPromiseConstructorSymbol(reportErrors: boolean): Symbol | undefined {
             return deferredGlobalPromiseConstructorSymbol || (deferredGlobalPromiseConstructorSymbol = getGlobalValueSymbol("Promise" as __String, reportErrors));
         }
@@ -7537,7 +7563,15 @@ namespace ts {
         function getTypeFromTypeOperatorNode(node: TypeOperatorNode) {
             const links = getNodeLinks(node);
             if (!links.resolvedType) {
-                links.resolvedType = getIndexType(getTypeFromTypeNode(node.type));
+                const type = getTypeFromTypeNode(node.type);
+                switch (node.operator) {
+                    case SyntaxKind.KeyOfKeyword:
+                        links.resolvedType = getIndexType(type);
+                        break;
+                    case SyntaxKind.AwaitedKeyword:
+                        links.resolvedType = getAwaitedType(type) || unknownType;
+                        break;
+                }
             }
             return links.resolvedType;
         }
@@ -8364,6 +8398,9 @@ namespace ts {
             if (type.flags & TypeFlags.IndexedAccess) {
                 return getIndexedAccessType(instantiateType((<IndexedAccessType>type).objectType, mapper), instantiateType((<IndexedAccessType>type).indexType, mapper));
             }
+            if (type.flags & TypeFlags.Awaited) {
+                return getAwaitedType(instantiateType((<IndexType>type).type, mapper)) || unknownType;
+            }
             return type;
         }
 
@@ -9318,6 +9355,15 @@ namespace ts {
                         }
                     }
                 }
+                else if (target.flags & TypeFlags.Awaited && source.flags & TypeFlags.Awaited) {
+                    // A awaited S is related to a awaited T if S is related to T:
+                    //
+                    //  S <: T ⇒ awaited S <: awaited T
+                    //
+                    if (result = isRelatedTo((<AwaitedType>source).type, (<AwaitedType>target).type, reportErrors)) {
+                        return result;
+                    }
+                }
 
                 if (source.flags & TypeFlags.TypeParameter) {
                     // A source type T is related to a target type { [P in keyof T]: X } if T[P] is related to X.
@@ -9365,6 +9411,19 @@ namespace ts {
                         }
                     }
                 }
+                else if (source.flags & TypeFlags.Awaited) {
+                    // A awaited S is related to T if awaited C is related to T, where C is the
+                    // constraint of S:
+                    //
+                    //  S <: C ^ awaited C <: T ⇒ awaited S <: T
+                    //
+                    const constraint = getConstraintOfType((<AwaitedType>source).type);
+                    if (constraint) {
+                        if (result = isRelatedTo(getAwaitedType(constraint), target, reportErrors)) {
+                            return result;
+                        }
+                    }
+                }
                 else {
                     if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.Reference && (<TypeReference>source).target === (<TypeReference>target).target) {
                         // We have type references to same target type, see if relationship holds for all type arguments
@@ -16705,7 +16764,7 @@ namespace ts {
             // creates a `Promise<T>` type where `T` is the promisedType argument
             const globalPromiseType = getGlobalPromiseType(/*reportErrors*/ true);
             if (globalPromiseType !== emptyGenericType) {
-                // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type
+                // if the awaited type is itself a promise, get the underlying type; otherwise, fallback to the awaited type
                 promisedType = getAwaitedType(promisedType) || emptyObjectType;
                 return createTypeReference(<GenericType>globalPromiseType, [promisedType]);
             }
@@ -17011,14 +17070,14 @@ namespace ts {
 
             const functionFlags = getFunctionFlags(node);
             const returnTypeNode = getEffectiveReturnTypeNode(node);
-            const returnOrPromisedType = returnTypeNode &&
+            const returnOrAwaitedType = returnTypeNode &&
                 ((functionFlags & FunctionFlags.AsyncGenerator) === FunctionFlags.Async ?
                     checkAsyncFunctionReturnType(node) : // Async function
                     getTypeFromTypeNode(returnTypeNode)); // AsyncGenerator function, Generator function, or normal function
 
             if ((functionFlags & FunctionFlags.Generator) === 0) { // Async function or normal function
                 // return is not necessary in the body of generators
-                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrAwaitedType);
             }
 
             if (node.body) {
@@ -17038,16 +17097,16 @@ namespace ts {
                     // From within an async function you can return either a non-promise value or a promise. Any
                     // Promise/A+ compatible implementation will always assimilate any foreign promise, so we
                     // should not be checking assignability of a promise to the return type. Instead, we need to
-                    // check assignability of the awaited type of the expression body against the promised type of
+                    // check assignability of the awaited type of the expression body against the awaited type of
                     // its return type annotation.
                     const exprType = checkExpression(<Expression>node.body);
-                    if (returnOrPromisedType) {
+                    if (returnOrAwaitedType) {
                         if ((functionFlags & FunctionFlags.AsyncGenerator) === FunctionFlags.Async) { // Async function
                             const awaitedType = checkAwaitedType(exprType, node.body, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
-                            checkTypeAssignableTo(awaitedType, returnOrPromisedType, node.body);
+                            checkTypeAssignableTo(awaitedType, returnOrAwaitedType, node.body);
                         }
                         else { // Normal function
-                            checkTypeAssignableTo(exprType, returnOrPromisedType, node.body);
+                            checkTypeAssignableTo(exprType, returnOrAwaitedType, node.body);
                         }
                     }
                 }
@@ -19199,19 +19258,18 @@ namespace ts {
             }
         }
 
-        function getAwaitedTypeOfPromise(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
-            const promisedType = getPromisedTypeOfPromise(type, errorNode);
-            return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage);
-        }
-
         /**
-         * Gets the "promised type" of a promise.
-         * @param type The type of the promise.
-         * @remarks The "promised type" of a type is the type of the "value" parameter of the "onfulfilled" callback.
+         * Gets the explicit "fulfillment type" of a Promise-like type.
+         *
+         * The "fulfillment type" of a type is the type of the "value" parameter of the
+         * "onfulfilled" callback. This function **does not** recursively unwrap the
+         * "fulfillment type".
+         *
+         * If the type is not Promise-like, `undefined` is returned.
          */
-        function getPromisedTypeOfPromise(promise: Type, errorNode?: Node): Type {
+        function getFulfillmentTypeOfPromise(type: Type, errorNode?: Node): Type | undefined {
             //
-            //  { // promise
+            //  { // type
             //      then( // thenFunction
             //          onfulfilled: ( // onfulfilledParameterType
             //              value: T // valueParameterType
@@ -19220,20 +19278,21 @@ namespace ts {
             //  }
             //
 
-            if (isTypeAny(promise)) {
+            if (isTypeAny(type)) {
                 return undefined;
             }
 
-            const typeAsPromise = <PromiseOrAwaitableType>promise;
-            if (typeAsPromise.promisedTypeOfPromise) {
-                return typeAsPromise.promisedTypeOfPromise;
+            const typeAsPromise = <PromiseOrAwaitableType>type;
+            if (typeAsPromise.fulfillmentType) {
+                return typeAsPromise.fulfillmentType;
             }
 
-            if (isReferenceToType(promise, getGlobalPromiseType(/*reportErrors*/ false))) {
-                return typeAsPromise.promisedTypeOfPromise = (<GenericType>promise).typeArguments[0];
+            if (isReferenceToType(type, getGlobalPromiseType(/*reportErrors*/ false)) ||
+                isReferenceToType(type, getGlobalPromiseLikeType(/*reportErrors*/ false))) {
+                return typeAsPromise.fulfillmentType = (<GenericType>type).typeArguments[0];
             }
 
-            const thenFunction = getTypeOfPropertyOfType(promise, "then" as __String);
+            const thenFunction = getTypeOfPropertyOfType(type, "then" as __String);
             if (isTypeAny(thenFunction)) {
                 return undefined;
             }
@@ -19259,50 +19318,117 @@ namespace ts {
                 return undefined;
             }
 
-            return typeAsPromise.promisedTypeOfPromise = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), /*subtypeReduction*/ true);
+            return typeAsPromise.fulfillmentType = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), /*subtypeReduction*/ true);
         }
 
         /**
-         * Gets the "awaited type" of a type.
-         * @param type The type to await.
-         * @remarks The "awaited type" of an expression is its "promised type" if the expression is a
-         * Promise-like type; otherwise, it is the type of the expression. This is used to reflect
-         * The runtime behavior of the `await` keyword.
+         * Gets or creates a `awaited T` type for a type variable.
+         *
+         * The "awaited type" of a type variable cannot be determined until it is instantiated. As
+         * a result, a `PromisedType` for the type variable is created that can be instantiated
+         * or related later.
          */
-        function checkAwaitedType(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage): Type {
-            return getAwaitedType(type, errorNode, diagnosticMessage) || unknownType;
+        function getAwaitedTypeForGenericType(type: TypeVariable | UnionOrIntersectionType) {
+            if (!type.resolvedAwaitedType) {
+                type.resolvedAwaitedType = <AwaitedType>createType(TypeFlags.Awaited);
+                type.resolvedAwaitedType.type = type;
+            }
+            return type.resolvedAwaitedType;
         }
 
+        /**
+         * Gets the "awaited type" of a type.
+         *
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
+         * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
+         * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
+         * non-promise type is found.
+         *
+         * This is used to reflect the runtime behavior of the `await` keyword and the `awaited T`
+         * type.
+         */
+        function getAwaitedType(type: Type): Type | undefined;
+        /**
+         * Gets the "awaited type" of a type.
+         *
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
+         * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
+         * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
+         * non-promise type is found.
+         *
+         * This is used to reflect the runtime behavior of the `await` keyword and the `awaited T`
+         * type.
+         */
+        function getAwaitedType(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage): Type | undefined;
+        /**
+         * Gets the "awaited type" of a type.
+         *
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
+         * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
+         * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
+         * non-promise type is found.
+         *
+         * This is used to reflect the runtime behavior of the `await` keyword and the `awaited T`
+         * type.
+         */
         function getAwaitedType(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
-            const typeAsAwaitable = <PromiseOrAwaitableType>type;
-            if (typeAsAwaitable.awaitedTypeOfType) {
-                return typeAsAwaitable.awaitedTypeOfType;
-            }
+            // For a union, get a union of the awaited types of each constituent.
+            //
+            // For example:
+            //
+            //   number | string          -> number | string
+            //   number | Promise<string> -> number | string
+            //   T | string               -> awaited T | string
+            //   T | Promise<string>      -> awaited T | string
+            //   T | Promise<never>       -> awaited T
+            //   T | U                    -> awaited T | awaited U
+            //
+            // We treat intersection types as any other value.
+            //
+            // For example:
+            //
+            //   A & B          -> awaited (A & B)
+            //   A & Promise<B> -> awaited B
+            //
+            return mapType(type, errorNode ? constituentType => getAwaitedTypeWorker(constituentType, errorNode, diagnosticMessage) : getAwaitedTypeWorker);
+        }
 
-            if (isTypeAny(type)) {
-                return typeAsAwaitable.awaitedTypeOfType = type;
+        function getAwaitedTypeWorker(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
+            // If the type is already a awaited type, return it.
+            //
+            // For example:
+            //
+            //   awaited T -> awaited T
+            //
+            if (type.flags & TypeFlags.Awaited) {
+                return type;
             }
 
-            if (type.flags & TypeFlags.Union) {
-                let types: Type[];
-                for (const constituentType of (<UnionType>type).types) {
-                    types = append(types, getAwaitedType(constituentType, errorNode, diagnosticMessage));
-                }
+            // We cannot resolve the awaited type for a type variable until it is instantiated. As
+            // such, we create a `awaited T` type that can either be instantiated or related later.
+            //
+            // For example:
+            //
+            //   T -> awaited T
+            //
+            if (type.flags & TypeFlags.TypeVariable) {
+                return getAwaitedTypeForGenericType(<TypeVariable>type);
+            }
 
-                if (!types) {
-                    return undefined;
-                }
+            const typeAsAwaitable = <PromiseOrAwaitableType>type;
 
-                return typeAsAwaitable.awaitedTypeOfType = getUnionType(types, /*subtypeReduction*/ true);
+            // Use the cached type if already computed.
+            if (typeAsAwaitable.awaitedType) {
+                return typeAsAwaitable.awaitedType;
             }
 
-            const promisedType = getPromisedTypeOfPromise(type);
-            if (promisedType) {
-                if (type.id === promisedType.id || indexOf(awaitedTypeStack, promisedType.id) >= 0) {
+            const fulfillmentType = getFulfillmentTypeOfPromise(type);
+            if (fulfillmentType) {
+                if (type === fulfillmentType || awaitedTypeStack.lastIndexOf(fulfillmentType) >= 0) {
                     // Verify that we don't have a bad actor in the form of a promise whose
-                    // promised type is the same as the promise type, or a mutually recursive
-                    // promise. If so, we return undefined as we cannot guess the shape. If this
-                    // were the actual case in the JavaScript, this Promise would never resolve.
+                    // "fulfillment type" is the same as the promise, or a mutually recursive
+                    // promise. If so, we return `undefined` as we cannot guess the shape. If this
+                    // were the actual case in the JavaScript, this promise would never resolve.
                     //
                     // An example of a bad actor with a singly-recursive promise type might
                     // be:
@@ -19312,8 +19438,9 @@ namespace ts {
                     //          onfulfilled: (value: BadPromise) => any,
                     //          onrejected: (error: any) => any): BadPromise;
                     //  }
-                    // The above interface will pass the PromiseLike check, and return a
-                    // promised type of `BadPromise`. Since this is a self reference, we
+                    //
+                    // The above interface will pass the PromiseLike check and return a
+                    // awaited type of `BadPromise`. Since this is a self reference, we
                     // don't want to keep recursing ad infinitum.
                     //
                     // An example of a bad actor in the form of a mutually-recursive
@@ -19339,21 +19466,16 @@ namespace ts {
 
                 // Keep track of the type we're about to unwrap to avoid bad recursive promise types.
                 // See the comments above for more information.
-                awaitedTypeStack.push(type.id);
-                const awaitedType = getAwaitedType(promisedType, errorNode, diagnosticMessage);
+                awaitedTypeStack.push(type);
+                const awaitedType = getAwaitedType(fulfillmentType, errorNode, diagnosticMessage);
                 awaitedTypeStack.pop();
-
-                if (!awaitedType) {
-                    return undefined;
-                }
-
-                return typeAsAwaitable.awaitedTypeOfType = awaitedType;
+                return typeAsAwaitable.awaitedType = awaitedType;
             }
 
             // The type was not a promise, so it could not be unwrapped any further.
             // As long as the type does not have a callable "then" property, it is
             // safe to return the type; otherwise, an error will be reported in
-            // the call to getNonThenableType and we will return undefined.
+            // the call to `getNonThenableType` and we will return `undefined`.
             //
             // An example of a non-promise "thenable" might be:
             //
@@ -19364,17 +19486,68 @@ namespace ts {
             // will never settle. We treat this as an error to help flag an early indicator
             // of a runtime problem. If the user wants to return this value from an async
             // function, they would need to wrap it in some other value. If they want it to
-            // be treated as a promise, they can cast to <any>.
+            // be treated as a promise, they can cast to `any`.
             const thenFunction = getTypeOfPropertyOfType(type, "then" as __String);
             if (thenFunction && getSignaturesOfType(thenFunction, SignatureKind.Call).length > 0) {
                 if (errorNode) {
-                    Debug.assert(!!diagnosticMessage);
                     error(errorNode, diagnosticMessage);
                 }
                 return undefined;
             }
 
-            return typeAsAwaitable.awaitedTypeOfType = type;
+            return typeAsAwaitable.awaitedType = type;
+        }
+
+        /**
+         * Checks the "awaited type" of a type.
+         *
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
+         * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
+         * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
+         * non-promise type is found.
+         *
+         * If `type` is not Promise-like, `type` is returned.
+         * If the "awaited type" of `type` is a non-promise "thenable", `unknownType` is returned.
+         */
+        function checkAwaitedType(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage): Type {
+            return getAwaitedType(type, errorNode, diagnosticMessage) || unknownType;
+        }
+
+        /**
+         * Gets the "awaited type" of a Promise-like type.
+         *
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
+         * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
+         * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
+         * non-promise type is found.
+         *
+         * If `type` is not Promise-like, `undefined` is returned.
+         */
+        function getAwaitedTypeOfPromise(type: Type): Type | undefined;
+        /**
+         * Gets the "awaited type" of a Promise-like type.
+         *
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
+         * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
+         * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
+         * non-promise type is found.
+         *
+         * If `type` is not Promise-like, `undefined` is returned.
+         */
+        function getAwaitedTypeOfPromise(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage): Type | undefined;
+        /**
+         * Gets the "awaited type" of a Promise-like type.
+         *
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
+         * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
+         * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
+         * non-promise type is found.
+         *
+         * If `type` is not Promise-like, `undefined` is returned.
+         */
+        function getAwaitedTypeOfPromise(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
+            const fulfillmentType = getFulfillmentTypeOfPromise(type, errorNode);
+            return fulfillmentType && getAwaitedType(fulfillmentType, errorNode, diagnosticMessage);
         }
 
         /**
@@ -19746,10 +19919,10 @@ namespace ts {
 
             const returnTypeNode = getEffectiveReturnTypeNode(node);
             if ((functionFlags & FunctionFlags.Generator) === 0) { // Async function or normal function
-                const returnOrPromisedType = returnTypeNode && (functionFlags & FunctionFlags.Async
+                const returnOrAwaitedType = returnTypeNode && (functionFlags & FunctionFlags.Async
                     ? checkAsyncFunctionReturnType(node) // Async function
                     : getTypeFromTypeNode(returnTypeNode)); // normal function
-                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrAwaitedType);
             }
 
             if (produceDiagnostics && !returnTypeNode) {
@@ -20895,7 +21068,7 @@ namespace ts {
 
         function isUnwrappedReturnTypeVoidOrAny(func: FunctionLike, returnType: Type): boolean {
             const unwrappedReturnType = (getFunctionFlags(func) & FunctionFlags.AsyncGenerator) === FunctionFlags.Async
-                ? getPromisedTypeOfPromise(returnType) // Async function
+                ? getFulfillmentTypeOfPromise(returnType) // Async function
                 : returnType; // AsyncGenerator function, Generator function, or normal function
             return unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, TypeFlags.Void | TypeFlags.Any);
         }
@@ -20936,13 +21109,13 @@ namespace ts {
                     }
                     else if (getEffectiveReturnTypeNode(func) || isGetAccessorWithAnnotatedSetAccessor(func)) {
                         if (functionFlags & FunctionFlags.Async) { // Async function
-                            const promisedType = getPromisedTypeOfPromise(returnType);
+                            const fulfillmentType = getFulfillmentTypeOfPromise(returnType);
                             const awaitedType = checkAwaitedType(exprType, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
-                            if (promisedType) {
-                                // If the function has a return type, but promisedType is
+                            if (fulfillmentType) {
+                                // If the function has a return type, but fulfillmentType is
                                 // undefined, an error will be reported in checkAsyncFunctionReturnType
                                 // so we don't need to report one here.
-                                checkTypeAssignableTo(awaitedType, promisedType, node);
+                                checkTypeAssignableTo(awaitedType, fulfillmentType, node);
                             }
                         }
                         else {
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index f94ac9a75c5e2..855c0a687b37d 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -387,6 +387,20 @@ namespace ts {
         return result;
     }
 
+    export function mapDefined<T, U>(array: ReadonlyArray<T> | undefined, mapFn: (x: T, i: number) => U | undefined): U[] {
+        const result: U[] = [];
+        if (array) {
+            for (let i = 0; i < array.length; i++) {
+                const item = array[i];
+                const mapped = mapFn(item, i);
+                if (mapped !== undefined) {
+                    result.push(mapped);
+                }
+            }
+        }
+        return result;
+    }
+
     // Maps from T to T and avoids allocation if all elements map to themselves
     export function sameMap<T>(array: T[], f: (x: T, i: number) => T): T[];
     export function sameMap<T>(array: ReadonlyArray<T>, f: (x: T, i: number) => T): ReadonlyArray<T>;
@@ -410,6 +424,36 @@ namespace ts {
         return result || array;
     }
 
+    // Maps from T to T and avoids allocation if all elements map to themselves. Undefined elements are not added.
+    export function sameMapDefined<T>(array: (T | undefined)[], f: (x: T, i: number) => T | undefined): T[] | undefined;
+    export function sameMapDefined<T>(array: ReadonlyArray<T | undefined>, f: (x: T, i: number) => T | undefined): ReadonlyArray<T> | undefined;
+    export function sameMapDefined<T>(array: (T | undefined)[], f: (x: T, i: number) => T | undefined): T[] | undefined {
+        let result: T[];
+        if (array) {
+            let lastUndefinedOffset = -1;
+            for (let i = 0; i < array.length; i++) {
+                const item = array[i];
+                const mapped = item !== undefined ? f(item, i) : undefined;
+                if (result) {
+                    if (mapped !== undefined) {
+                        result.push(mapped);
+                    }
+                }
+                else if (mapped === undefined) {
+                    lastUndefinedOffset = i;
+                }
+                else if (item !== mapped) {
+                    result = array.slice(lastUndefinedOffset + 1, i);
+                    result.push(mapped);
+                }
+            }
+            if (!result && lastUndefinedOffset > -1) {
+                return undefined;
+            }
+        }
+        return result || array;
+    }
+
     /**
      * Flattens an array containing a mix of array or non-array elements.
      *
@@ -501,20 +545,6 @@ namespace ts {
         return result || array;
     }
 
-    export function mapDefined<T, U>(array: ReadonlyArray<T> | undefined, mapFn: (x: T, i: number) => U | undefined): U[] {
-        const result: U[] = [];
-        if (array) {
-            for (let i = 0; i < array.length; i++) {
-                const item = array[i];
-                const mapped = mapFn(item, i);
-                if (mapped !== undefined) {
-                    result.push(mapped);
-                }
-            }
-        }
-        return result;
-    }
-
     /**
      * Computes the first matching span of elements and returns a tuple of the first span
      * and the remaining elements.
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 4492c3ed47426..42037d5d2b500 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -730,15 +730,15 @@ namespace ts {
         return <ThisTypeNode>createSynthesizedNode(SyntaxKind.ThisType);
     }
 
-    export function createTypeOperatorNode(type: TypeNode) {
+    export function createTypeOperatorNode(type: TypeNode, operator: SyntaxKind.KeyOfKeyword | SyntaxKind.AwaitedKeyword) {
         const node = createSynthesizedNode(SyntaxKind.TypeOperator) as TypeOperatorNode;
-        node.operator = SyntaxKind.KeyOfKeyword;
+        node.operator = operator;
         node.type = parenthesizeElementTypeMember(type);
         return node;
     }
 
     export function updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode) {
-        return node.type !== type ? updateNode(createTypeOperatorNode(type), node) : node;
+        return node.type !== type ? updateNode(createTypeOperatorNode(type, node.operator), node) : node;
     }
 
     export function createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode) {
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 7486c7541bed4..db95a562d42e3 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -2782,7 +2782,7 @@ namespace ts {
             return type;
         }
 
-        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword) {
+        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.AwaitedKeyword) {
             const node = <TypeOperatorNode>createNode(SyntaxKind.TypeOperator);
             parseExpected(operator);
             node.operator = operator;
@@ -2791,9 +2791,11 @@ namespace ts {
         }
 
         function parseTypeOperatorOrHigher(): TypeNode {
-            switch (token()) {
+            const keyword = token();
+            switch (keyword) {
                 case SyntaxKind.KeyOfKeyword:
-                    return parseTypeOperator(SyntaxKind.KeyOfKeyword);
+                case SyntaxKind.AwaitedKeyword:
+                    return parseTypeOperator(keyword);
             }
             return parseArrayTypeOrHigher();
         }
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index a130d8427daad..2eb9e1a75be49 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -62,6 +62,7 @@ namespace ts {
         "abstract": SyntaxKind.AbstractKeyword,
         "any": SyntaxKind.AnyKeyword,
         "as": SyntaxKind.AsKeyword,
+        "awaited": SyntaxKind.AwaitedKeyword,
         "boolean": SyntaxKind.BooleanKeyword,
         "break": SyntaxKind.BreakKeyword,
         "case": SyntaxKind.CaseKeyword,
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index f5cca6a68204a..08db779d7bec9 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -190,6 +190,7 @@ namespace ts {
         ModuleKeyword,
         NamespaceKeyword,
         NeverKeyword,
+        AwaitedKeyword,
         ReadonlyKeyword,
         RequireKeyword,
         NumberKeyword,
@@ -972,7 +973,7 @@ namespace ts {
 
     export interface TypeOperatorNode extends TypeNode {
         kind: SyntaxKind.TypeOperator;
-        operator: SyntaxKind.KeyOfKeyword;
+        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.AwaitedKeyword;
         type: TypeNode;
     }
 
@@ -3140,17 +3141,18 @@ namespace ts {
         Intersection            = 1 << 17,  // Intersection (T & U)
         Index                   = 1 << 18,  // keyof T
         IndexedAccess           = 1 << 19,  // T[K]
+        Awaited                 = 1 << 20,  // awaited T
         /* @internal */
-        FreshLiteral            = 1 << 20,  // Fresh literal type
+        FreshLiteral            = 1 << 21,  // Fresh literal type
         /* @internal */
-        ContainsWideningType    = 1 << 21,  // Type is or contains undefined or null widening type
+        ContainsWideningType    = 1 << 22,  // Type is or contains undefined or null widening type
         /* @internal */
-        ContainsObjectLiteral   = 1 << 22,  // Type is or contains object literal type
+        ContainsObjectLiteral   = 1 << 23,  // Type is or contains object literal type
         /* @internal */
-        ContainsAnyFunctionType = 1 << 23,  // Type is or contains the anyFunctionType
-        NonPrimitive            = 1 << 24,  // intrinsic object type
+        ContainsAnyFunctionType = 1 << 24,  // Type is or contains the anyFunctionType
+        NonPrimitive            = 1 << 25,  // intrinsic object type
         /* @internal */
-        JsxAttributes           = 1 << 25,  // Jsx attributes type
+        JsxAttributes           = 1 << 26,  // Jsx attributes type
 
         /* @internal */
         Nullable = Undefined | Null,
@@ -3169,12 +3171,12 @@ namespace ts {
         EnumLike = Enum | EnumLiteral,
         UnionOrIntersection = Union | Intersection,
         StructuredType = Object | Union | Intersection,
-        StructuredOrTypeVariable = StructuredType | TypeParameter | Index | IndexedAccess,
-        TypeVariable = TypeParameter | IndexedAccess,
+        StructuredOrTypeVariable = StructuredType | TypeParameter | Index | IndexedAccess | Awaited,
+        TypeVariable = TypeParameter | IndexedAccess | Awaited,
 
         // 'Narrowable' types are types where narrowing actually narrows.
         // This *should* be every type other than null, undefined, void, and never
-        Narrowable = Any | StructuredType | TypeParameter | Index | IndexedAccess | StringLike | NumberLike | BooleanLike | ESSymbol | NonPrimitive,
+        Narrowable = Any | StructuredType | TypeParameter | Index | IndexedAccess | StringLike | NumberLike | BooleanLike | ESSymbol | NonPrimitive | Awaited,
         NotUnionOrUnit = Any | ESSymbol | Object | NonPrimitive,
         /* @internal */
         RequiresWidening = ContainsWideningType | ContainsObjectLiteral,
@@ -3296,6 +3298,8 @@ namespace ts {
         resolvedBaseConstraint: Type;
         /* @internal */
         couldContainTypeVariables: boolean;
+        /* @internal */
+        resolvedAwaitedType: AwaitedType;
     }
 
     export interface UnionType extends UnionOrIntersectionType { }
@@ -3359,9 +3363,8 @@ namespace ts {
 
     /* @internal */
     export interface PromiseOrAwaitableType extends ObjectType, UnionType {
-        promiseTypeOfPromiseConstructor?: Type;
-        promisedTypeOfPromise?: Type;
-        awaitedTypeOfType?: Type;
+        fulfillmentType?: Type;     // Type of `value` parameter of `onfulfilled` callback.
+        awaitedType?: Type;         // The "fulfillment type" if a Promise-like, otherwise this type.
     }
 
     /* @internal */
@@ -3374,6 +3377,8 @@ namespace ts {
         resolvedBaseConstraint: Type;
         /* @internal */
         resolvedIndexType: IndexType;
+        /* @internal */
+        resolvedAwaitedType: AwaitedType;
     }
 
     // Type parameters (TypeFlags.TypeParameter)
@@ -3404,6 +3409,11 @@ namespace ts {
         type: TypeVariable | UnionOrIntersectionType;
     }
 
+    // awaited T types (TypeFlags.Awaited)
+    export interface AwaitedType extends Type {
+        type: TypeVariable;
+    }
+
     export const enum SignatureKind {
         Call,
         Construct,
diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index 049b1898b9b6f..008236b052eb4 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -197,7 +197,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>;
+    all<TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -205,7 +205,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T>(values: Iterable<T | PromiseLike<T>>): Promise<T>;
+    race<T>(values: Iterable<T>): Promise<awaited T>;
 }
 
 declare namespace Reflect {
diff --git a/src/lib/es2015.promise.d.ts b/src/lib/es2015.promise.d.ts
index ab33531191ffc..853c0cf8b0b8e 100644
--- a/src/lib/es2015.promise.d.ts
+++ b/src/lib/es2015.promise.d.ts
@@ -18,7 +18,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9, awaited T10]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -26,7 +26,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -34,7 +34,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -42,7 +42,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>;
+    all<T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -50,7 +50,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>;
+    all<T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -58,7 +58,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>;
+    all<T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -66,7 +66,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>]): Promise<[T1, T2, T3, T4]>;
+    all<T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -74,7 +74,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>;
+    all<T1, T2, T3>(values: [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -82,7 +82,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>;
+    all<T1, T2>(values: [T1, T2]): Promise<[awaited T1, awaited T2]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -90,7 +90,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T>(values: (T | PromiseLike<T>)[]): Promise<T[]>;
+    all<T>(values: T[]): Promise<(awaited T)[]>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -98,7 +98,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10>;
+    race<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5 | awaited T6 | awaited T7 | awaited T8 | awaited T9 | awaited T10>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -106,7 +106,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
+    race<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5 | awaited T6 | awaited T7 | awaited T8 | awaited T9>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -114,7 +114,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
+    race<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5 | awaited T6 | awaited T7 | awaited T8>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -122,7 +122,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
+    race<T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5 | awaited T6 | awaited T7>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -130,7 +130,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<T1 | T2 | T3 | T4 | T5 | T6>;
+    race<T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5 | awaited T6>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -138,7 +138,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<T1 | T2 | T3 | T4 | T5>;
+    race<T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -146,7 +146,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<T1 | T2 | T3 | T4>;
+    race<T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -154,7 +154,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<T1 | T2 | T3>;
+    race<T1, T2, T3>(values: [T1, T2, T3]): Promise<awaited T1 | awaited T2 | awaited T3>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -162,7 +162,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<T1 | T2>;
+    race<T1, T2>(values: [T1, T2]): Promise<awaited T1 | awaited T2>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -170,7 +170,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T>(values: (T | PromiseLike<T>)[]): Promise<T>;
+    race<T>(values: T[]): Promise<awaited T>;
 
     /**
      * Creates a new rejected promise for the provided reason.
@@ -184,14 +184,14 @@ interface PromiseConstructor {
      * @param reason The reason the promise was rejected.
      * @returns A new rejected Promise.
      */
-    reject<T>(reason: any): Promise<T>;
+    reject<T>(reason: any): 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<T>;
+    resolve<T>(value: T): Promise<awaited T>;
 
     /**
      * Creates a new resolved promise .
diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
index 32fb2f55b4def..e5845571a4f48 100644
--- a/src/lib/es5.d.ts
+++ b/src/lib/es5.d.ts
@@ -1259,7 +1259,7 @@ interface PromiseLike<T> {
      * @param onrejected The callback to execute when the Promise is rejected.
      * @returns A Promise for the completion of which ever callback is executed.
      */
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: awaited T) => TResult1) | undefined | null, onrejected?: ((reason: any) => TResult2) | undefined | null): PromiseLike<awaited TResult1 | awaited TResult2>;
 }
 
 /**
@@ -1272,14 +1272,14 @@ interface Promise<T> {
      * @param onrejected The callback to execute when the Promise is rejected.
      * @returns A Promise for the completion of which ever callback is executed.
      */
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: awaited T) => TResult1) | undefined | null, onrejected?: ((reason: any) => TResult2) | undefined | null): Promise<awaited TResult1 | awaited TResult2>;
 
     /**
      * Attaches a callback for only the rejection of the Promise.
      * @param onrejected The callback to execute when the Promise is rejected.
      * @returns A Promise for the completion of the callback.
      */
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult) | undefined | null): Promise<awaited T | awaited TResult>;
 }
 
 interface ArrayLike<T> {
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es2017.types b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es2017.types
index 57f59302bb5bc..dbf81dbba277e 100644
--- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es2017.types
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es2017.types
@@ -6,9 +6,9 @@ class C {
 >method : () => void
 
       var fn = async () => await this;      
->fn : () => Promise<this>
->async () => await this : () => Promise<this>
->await this : this
+>fn : () => Promise<awaited this>
+>async () => await this : () => Promise<awaited this>
+>await this : awaited this
 >this : this
    }
 }
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es5.types b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es5.types
index da378ee2718f9..799c77e77c78d 100644
--- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es5.types
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es5.types
@@ -6,9 +6,9 @@ class C {
 >method : () => void
 
       var fn = async () => await this;
->fn : () => Promise<this>
->async () => await this : () => Promise<this>
->await this : this
+>fn : () => Promise<awaited this>
+>async () => await this : () => Promise<awaited this>
+>await this : awaited this
 >this : this
    }
 }
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types
index 5386a956ada9a..bfab27d8b3806 100644
--- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types
@@ -6,9 +6,9 @@ class C {
 >method : () => void
 
       var fn = async () => await this;      
->fn : () => Promise<this>
->async () => await this : () => Promise<this>
->await this : this
+>fn : () => Promise<awaited this>
+>async () => await this : () => Promise<awaited this>
+>await this : awaited this
 >this : this
    }
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
index 027551ae4b822..a31727a47ddab 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
+++ b/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
@@ -6,8 +6,8 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(10,23): error TS1055: Type 'typeof Thenable' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
   Type 'Thenable' is not assignable to type 'PromiseLike<T>'.
     Types of property 'then' are incompatible.
-      Type '() => void' is not assignable to type '<TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<TResult1 | TResult2>'.
-        Type 'void' is not assignable to type 'PromiseLike<TResult1 | TResult2>'.
+      Type '() => void' is not assignable to type '<TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2) => PromiseLike<awaited TResult1 | awaited TResult2>'.
+        Type 'void' is not assignable to type 'PromiseLike<awaited TResult1 | awaited TResult2>'.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(17,16): error TS1058: The return type of an async function must either be a valid promise or must not contain a callable 'then' member.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(23,25): error TS1320: Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member.
 
@@ -37,8 +37,8 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1
 !!! error TS1055: Type 'typeof Thenable' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
 !!! error TS1055:   Type 'Thenable' is not assignable to type 'PromiseLike<T>'.
 !!! error TS1055:     Types of property 'then' are incompatible.
-!!! error TS1055:       Type '() => void' is not assignable to type '<TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<TResult1 | TResult2>'.
-!!! error TS1055:         Type 'void' is not assignable to type 'PromiseLike<TResult1 | TResult2>'.
+!!! error TS1055:       Type '() => void' is not assignable to type '<TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2) => PromiseLike<awaited TResult1 | awaited TResult2>'.
+!!! error TS1055:         Type 'void' is not assignable to type 'PromiseLike<awaited TResult1 | awaited TResult2>'.
     async function fn7() { return; } // valid: Promise<void>
     async function fn8() { return 1; } // valid: Promise<number>
     async function fn9() { return null; } // valid: Promise<any>
diff --git a/tests/baselines/reference/asyncFunctionReturnType.types b/tests/baselines/reference/asyncFunctionReturnType.types
index d1dab14ba87c6..ad402c6c40ffb 100644
--- a/tests/baselines/reference/asyncFunctionReturnType.types
+++ b/tests/baselines/reference/asyncFunctionReturnType.types
@@ -53,9 +53,9 @@ async function fIndexedTypeForPromiseOfStringProp(obj: Obj): Promise<Obj["string
 
     return Promise.resolve(obj.stringProp);
 >Promise.resolve(obj.stringProp) : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >obj.stringProp : string
 >obj : Obj
 >stringProp : string
@@ -70,9 +70,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 : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Obj : Obj
 >obj.stringProp : string
 >obj : Obj
@@ -101,9 +101,9 @@ async function fIndexedTypeForPromiseOfAnyProp(obj: Obj): Promise<Obj["anyProp"]
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve(obj.anyProp) : Promise<any>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >obj.anyProp : any
 >obj : Obj
 >anyProp : any
@@ -118,9 +118,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 : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Obj : Obj
 >obj.anyProp : any
 >obj : Obj
@@ -153,9 +153,9 @@ async function fGenericIndexedTypeForPromiseOfStringProp<TObj extends Obj>(obj:
 
     return Promise.resolve(obj.stringProp);
 >Promise.resolve(obj.stringProp) : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >obj.stringProp : string
 >obj : TObj
 >stringProp : string
@@ -171,10 +171,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfStringProp<TObj extends Ob
 >TObj : TObj
 
     return Promise.resolve<TObj["stringProp"]>(obj.stringProp);
->Promise.resolve<TObj["stringProp"]>(obj.stringProp) : Promise<TObj["stringProp"]>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve<TObj["stringProp"]>(obj.stringProp) : Promise<awaited TObj["stringProp"]>
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >TObj : TObj
 >obj.stringProp : string
 >obj : TObj
@@ -207,9 +207,9 @@ async function fGenericIndexedTypeForPromiseOfAnyProp<TObj extends Obj>(obj: TOb
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve(obj.anyProp) : Promise<any>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >obj.anyProp : any
 >obj : TObj
 >anyProp : any
@@ -225,10 +225,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
 >TObj : TObj
 
     return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
->Promise.resolve<TObj["anyProp"]>(obj.anyProp) : Promise<TObj["anyProp"]>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve<TObj["anyProp"]>(obj.anyProp) : Promise<awaited TObj["anyProp"]>
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >TObj : TObj
 >obj.anyProp : any
 >obj : TObj
@@ -270,10 +270,10 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
 >K : K
 
     return Promise.resolve(obj[key]);
->Promise.resolve(obj[key]) : Promise<TObj[K]>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve(obj[key]) : Promise<awaited TObj[K]>
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >obj[key] : TObj[K]
 >obj : TObj
 >key : K
@@ -294,10 +294,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
 >K : K
 
     return Promise.resolve<TObj[K]>(obj[key]);
->Promise.resolve<TObj[K]>(obj[key]) : Promise<TObj[K]>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve<TObj[K]>(obj[key]) : Promise<awaited TObj[K]>
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >TObj : TObj
 >K : K
 >obj[key] : TObj[K]
diff --git a/tests/baselines/reference/awaited.js b/tests/baselines/reference/awaited.js
new file mode 100644
index 0000000000000..0880ec68c4689
--- /dev/null
+++ b/tests/baselines/reference/awaited.js
@@ -0,0 +1,208 @@
+//// [awaited.ts]
+// simple
+declare const p0: Promise<number>;
+p0.then(x => x);
+
+declare const p1: Promise<Promise<number>>;
+p1.then(x => x);
+
+declare const p2: Promise<number | Promise<number>>;
+p2.then(x => x);
+
+// generics
+declare const f: boolean;
+declare function makePromise<T>(x: T): Promise<T>;
+makePromise(1).then(x => x);
+makePromise("a").then(x => x);
+makePromise({ a: 1 }).then(x => x);
+makePromise(f ? 1 : "a").then(x => x);
+
+function f0<U>(u: U) {
+    return makePromise(u).then(x => x);
+}
+f0(1).then(x => x);
+f0("a").then(x => x);
+f0(f ? 1 : "a").then(x => x);
+f0(makePromise(1)).then(x => x);
+
+function f1<U, V>(u: U, v: V) {
+    return makePromise(u).then(x => {
+        if (f) return x;
+        return makePromise(v).then(x => x);
+    });
+}
+f1(1, "a").then(x => x);
+f1(makePromise(1), makePromise("a")).then(x => x);
+
+function f2<U>(u: U) {
+    return makePromise(u).then(x => {
+        if (f) return x;
+        return Promise.reject("b");
+    });
+}
+f2(1).then(x => x);
+f2(makePromise(1)).then(x => x);
+
+function f3<U, V>(u: U, v: V) {
+    return makePromise(u).catch(x => v);
+}
+f3(1, "a").then(x => x);
+f3(makePromise(1), makePromise("a")).then(x => x);
+
+function f4<U, V>(u: U, v: V) {
+    return makePromise(u).catch(x => {
+        if (f) return v;
+        return Promise.reject("b");
+    });
+}
+f4(1, "a").then(x => x);
+f4(makePromise(1), makePromise("a")).then(x => x);
+
+async function f5<U>(u: Promise<U>) {
+    return await u;
+}
+f5(makePromise(1)).then(x => x);
+f5(makePromise(makePromise(1))).then(x => x);
+
+async function f6<U>(u: Promise<Promise<U>>) {
+    return await u;
+}
+
+// assignability
+let v0: number;
+let v1: awaited number;
+let v2: awaited Promise<number>;
+v0 = v1;
+v0 = v2;
+v1 = v0;
+v1 = v2;
+v2 = v0;
+v2 = v1;
+
+function f7<U>() {
+    let v0: awaited U;
+    let v1: awaited Promise<U>;
+    v0 = v1;
+    v1 = v0;
+}
+
+async function f8<U>() {
+    let pu: Promise<U>;
+    let v0: awaited U;
+    let v1: awaited Promise<U>;
+    v0 = await pu;
+    v1 = await pu;
+}
+
+//// [awaited.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+p0.then(x => x);
+p1.then(x => x);
+p2.then(x => x);
+makePromise(1).then(x => x);
+makePromise("a").then(x => x);
+makePromise({ a: 1 }).then(x => x);
+makePromise(f ? 1 : "a").then(x => x);
+function f0(u) {
+    return makePromise(u).then(x => x);
+}
+f0(1).then(x => x);
+f0("a").then(x => x);
+f0(f ? 1 : "a").then(x => x);
+f0(makePromise(1)).then(x => x);
+function f1(u, v) {
+    return makePromise(u).then(x => {
+        if (f)
+            return x;
+        return makePromise(v).then(x => x);
+    });
+}
+f1(1, "a").then(x => x);
+f1(makePromise(1), makePromise("a")).then(x => x);
+function f2(u) {
+    return makePromise(u).then(x => {
+        if (f)
+            return x;
+        return Promise.reject("b");
+    });
+}
+f2(1).then(x => x);
+f2(makePromise(1)).then(x => x);
+function f3(u, v) {
+    return makePromise(u).catch(x => v);
+}
+f3(1, "a").then(x => x);
+f3(makePromise(1), makePromise("a")).then(x => x);
+function f4(u, v) {
+    return makePromise(u).catch(x => {
+        if (f)
+            return v;
+        return Promise.reject("b");
+    });
+}
+f4(1, "a").then(x => x);
+f4(makePromise(1), makePromise("a")).then(x => x);
+function f5(u) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield u;
+    });
+}
+f5(makePromise(1)).then(x => x);
+f5(makePromise(makePromise(1))).then(x => x);
+function f6(u) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield u;
+    });
+}
+// assignability
+let v0;
+let v1;
+let v2;
+v0 = v1;
+v0 = v2;
+v1 = v0;
+v1 = v2;
+v2 = v0;
+v2 = v1;
+function f7() {
+    let v0;
+    let v1;
+    v0 = v1;
+    v1 = v0;
+}
+function f8() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let pu;
+        let v0;
+        let v1;
+        v0 = yield pu;
+        v1 = yield pu;
+    });
+}
+
+
+//// [awaited.d.ts]
+declare const p0: Promise<number>;
+declare const p1: Promise<Promise<number>>;
+declare const p2: Promise<number | Promise<number>>;
+declare const f: boolean;
+declare function makePromise<T>(x: T): Promise<T>;
+declare function f0<U>(u: U): Promise<awaited U>;
+declare function f1<U, V>(u: U, v: V): Promise<(awaited U) | (awaited V)>;
+declare function f2<U>(u: U): Promise<awaited U>;
+declare function f3<U, V>(u: U, v: V): Promise<(awaited U) | (awaited V)>;
+declare function f4<U, V>(u: U, v: V): Promise<(awaited U) | (awaited V)>;
+declare function f5<U>(u: Promise<U>): Promise<awaited U>;
+declare function f6<U>(u: Promise<Promise<U>>): Promise<awaited U>;
+declare let v0: number;
+declare let v1: awaited number;
+declare let v2: awaited Promise<number>;
+declare function f7<U>(): void;
+declare function f8<U>(): Promise<void>;
diff --git a/tests/baselines/reference/awaited.symbols b/tests/baselines/reference/awaited.symbols
new file mode 100644
index 0000000000000..440bd0895ce24
--- /dev/null
+++ b/tests/baselines/reference/awaited.symbols
@@ -0,0 +1,406 @@
+=== tests/cases/conformance/types/awaited/awaited.ts ===
+// simple
+declare const p0: Promise<number>;
+>p0 : Symbol(p0, Decl(awaited.ts, 1, 13))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+p0.then(x => x);
+>p0.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p0 : Symbol(p0, Decl(awaited.ts, 1, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 2, 8))
+>x : Symbol(x, Decl(awaited.ts, 2, 8))
+
+declare const p1: Promise<Promise<number>>;
+>p1 : Symbol(p1, Decl(awaited.ts, 4, 13))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+p1.then(x => x);
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(awaited.ts, 4, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 5, 8))
+>x : Symbol(x, Decl(awaited.ts, 5, 8))
+
+declare const p2: Promise<number | Promise<number>>;
+>p2 : Symbol(p2, Decl(awaited.ts, 7, 13))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+p2.then(x => x);
+>p2.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p2 : Symbol(p2, Decl(awaited.ts, 7, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 8, 8))
+>x : Symbol(x, Decl(awaited.ts, 8, 8))
+
+// generics
+declare const f: boolean;
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+
+declare function makePromise<T>(x: T): Promise<T>;
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>T : Symbol(T, Decl(awaited.ts, 12, 29))
+>x : Symbol(x, Decl(awaited.ts, 12, 32))
+>T : Symbol(T, Decl(awaited.ts, 12, 29))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>T : Symbol(T, Decl(awaited.ts, 12, 29))
+
+makePromise(1).then(x => x);
+>makePromise(1).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 13, 20))
+>x : Symbol(x, Decl(awaited.ts, 13, 20))
+
+makePromise("a").then(x => x);
+>makePromise("a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 14, 22))
+>x : Symbol(x, Decl(awaited.ts, 14, 22))
+
+makePromise({ a: 1 }).then(x => x);
+>makePromise({ a: 1 }).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>a : Symbol(a, Decl(awaited.ts, 15, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 15, 27))
+>x : Symbol(x, Decl(awaited.ts, 15, 27))
+
+makePromise(f ? 1 : "a").then(x => x);
+>makePromise(f ? 1 : "a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 16, 30))
+>x : Symbol(x, Decl(awaited.ts, 16, 30))
+
+function f0<U>(u: U) {
+>f0 : Symbol(f0, Decl(awaited.ts, 16, 38))
+>U : Symbol(U, Decl(awaited.ts, 18, 12))
+>u : Symbol(u, Decl(awaited.ts, 18, 15))
+>U : Symbol(U, Decl(awaited.ts, 18, 12))
+
+    return makePromise(u).then(x => x);
+>makePromise(u).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>u : Symbol(u, Decl(awaited.ts, 18, 15))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 19, 31))
+>x : Symbol(x, Decl(awaited.ts, 19, 31))
+}
+f0(1).then(x => x);
+>f0(1).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f0 : Symbol(f0, Decl(awaited.ts, 16, 38))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 21, 11))
+>x : Symbol(x, Decl(awaited.ts, 21, 11))
+
+f0("a").then(x => x);
+>f0("a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f0 : Symbol(f0, Decl(awaited.ts, 16, 38))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 22, 13))
+>x : Symbol(x, Decl(awaited.ts, 22, 13))
+
+f0(f ? 1 : "a").then(x => x);
+>f0(f ? 1 : "a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f0 : Symbol(f0, Decl(awaited.ts, 16, 38))
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 23, 21))
+>x : Symbol(x, Decl(awaited.ts, 23, 21))
+
+f0(makePromise(1)).then(x => x);
+>f0(makePromise(1)).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f0 : Symbol(f0, Decl(awaited.ts, 16, 38))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 24, 24))
+>x : Symbol(x, Decl(awaited.ts, 24, 24))
+
+function f1<U, V>(u: U, v: V) {
+>f1 : Symbol(f1, Decl(awaited.ts, 24, 32))
+>U : Symbol(U, Decl(awaited.ts, 26, 12))
+>V : Symbol(V, Decl(awaited.ts, 26, 14))
+>u : Symbol(u, Decl(awaited.ts, 26, 18))
+>U : Symbol(U, Decl(awaited.ts, 26, 12))
+>v : Symbol(v, Decl(awaited.ts, 26, 23))
+>V : Symbol(V, Decl(awaited.ts, 26, 14))
+
+    return makePromise(u).then(x => {
+>makePromise(u).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>u : Symbol(u, Decl(awaited.ts, 26, 18))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 27, 31))
+
+        if (f) return x;
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+>x : Symbol(x, Decl(awaited.ts, 27, 31))
+
+        return makePromise(v).then(x => x);
+>makePromise(v).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>v : Symbol(v, Decl(awaited.ts, 26, 23))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 29, 35))
+>x : Symbol(x, Decl(awaited.ts, 29, 35))
+
+    });
+}
+f1(1, "a").then(x => x);
+>f1(1, "a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f1 : Symbol(f1, Decl(awaited.ts, 24, 32))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 32, 16))
+>x : Symbol(x, Decl(awaited.ts, 32, 16))
+
+f1(makePromise(1), makePromise("a")).then(x => x);
+>f1(makePromise(1), makePromise("a")).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f1 : Symbol(f1, Decl(awaited.ts, 24, 32))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 33, 42))
+>x : Symbol(x, Decl(awaited.ts, 33, 42))
+
+function f2<U>(u: U) {
+>f2 : Symbol(f2, Decl(awaited.ts, 33, 50))
+>U : Symbol(U, Decl(awaited.ts, 35, 12))
+>u : Symbol(u, Decl(awaited.ts, 35, 15))
+>U : Symbol(U, Decl(awaited.ts, 35, 12))
+
+    return makePromise(u).then(x => {
+>makePromise(u).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>u : Symbol(u, Decl(awaited.ts, 35, 15))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 36, 31))
+
+        if (f) return x;
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+>x : Symbol(x, Decl(awaited.ts, 36, 31))
+
+        return Promise.reject("b");
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+    });
+}
+f2(1).then(x => x);
+>f2(1).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f2 : Symbol(f2, Decl(awaited.ts, 33, 50))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 41, 11))
+>x : Symbol(x, Decl(awaited.ts, 41, 11))
+
+f2(makePromise(1)).then(x => x);
+>f2(makePromise(1)).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f2 : Symbol(f2, Decl(awaited.ts, 33, 50))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 42, 24))
+>x : Symbol(x, Decl(awaited.ts, 42, 24))
+
+function f3<U, V>(u: U, v: V) {
+>f3 : Symbol(f3, Decl(awaited.ts, 42, 32))
+>U : Symbol(U, Decl(awaited.ts, 44, 12))
+>V : Symbol(V, Decl(awaited.ts, 44, 14))
+>u : Symbol(u, Decl(awaited.ts, 44, 18))
+>U : Symbol(U, Decl(awaited.ts, 44, 12))
+>v : Symbol(v, Decl(awaited.ts, 44, 23))
+>V : Symbol(V, Decl(awaited.ts, 44, 14))
+
+    return makePromise(u).catch(x => v);
+>makePromise(u).catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>u : Symbol(u, Decl(awaited.ts, 44, 18))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 45, 32))
+>v : Symbol(v, Decl(awaited.ts, 44, 23))
+}
+f3(1, "a").then(x => x);
+>f3(1, "a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f3 : Symbol(f3, Decl(awaited.ts, 42, 32))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 47, 16))
+>x : Symbol(x, Decl(awaited.ts, 47, 16))
+
+f3(makePromise(1), makePromise("a")).then(x => x);
+>f3(makePromise(1), makePromise("a")).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f3 : Symbol(f3, Decl(awaited.ts, 42, 32))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 48, 42))
+>x : Symbol(x, Decl(awaited.ts, 48, 42))
+
+function f4<U, V>(u: U, v: V) {
+>f4 : Symbol(f4, Decl(awaited.ts, 48, 50))
+>U : Symbol(U, Decl(awaited.ts, 50, 12))
+>V : Symbol(V, Decl(awaited.ts, 50, 14))
+>u : Symbol(u, Decl(awaited.ts, 50, 18))
+>U : Symbol(U, Decl(awaited.ts, 50, 12))
+>v : Symbol(v, Decl(awaited.ts, 50, 23))
+>V : Symbol(V, Decl(awaited.ts, 50, 14))
+
+    return makePromise(u).catch(x => {
+>makePromise(u).catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>u : Symbol(u, Decl(awaited.ts, 50, 18))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 51, 32))
+
+        if (f) return v;
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+>v : Symbol(v, Decl(awaited.ts, 50, 23))
+
+        return Promise.reject("b");
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+    });
+}
+f4(1, "a").then(x => x);
+>f4(1, "a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f4 : Symbol(f4, Decl(awaited.ts, 48, 50))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 56, 16))
+>x : Symbol(x, Decl(awaited.ts, 56, 16))
+
+f4(makePromise(1), makePromise("a")).then(x => x);
+>f4(makePromise(1), makePromise("a")).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f4 : Symbol(f4, Decl(awaited.ts, 48, 50))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 57, 42))
+>x : Symbol(x, Decl(awaited.ts, 57, 42))
+
+async function f5<U>(u: Promise<U>) {
+>f5 : Symbol(f5, Decl(awaited.ts, 57, 50))
+>U : Symbol(U, Decl(awaited.ts, 59, 18))
+>u : Symbol(u, Decl(awaited.ts, 59, 21))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>U : Symbol(U, Decl(awaited.ts, 59, 18))
+
+    return await u;
+>u : Symbol(u, Decl(awaited.ts, 59, 21))
+}
+f5(makePromise(1)).then(x => x);
+>f5(makePromise(1)).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f5 : Symbol(f5, Decl(awaited.ts, 57, 50))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 62, 24))
+>x : Symbol(x, Decl(awaited.ts, 62, 24))
+
+f5(makePromise(makePromise(1))).then(x => x);
+>f5(makePromise(makePromise(1))).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f5 : Symbol(f5, Decl(awaited.ts, 57, 50))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 63, 37))
+>x : Symbol(x, Decl(awaited.ts, 63, 37))
+
+async function f6<U>(u: Promise<Promise<U>>) {
+>f6 : Symbol(f6, Decl(awaited.ts, 63, 45))
+>U : Symbol(U, Decl(awaited.ts, 65, 18))
+>u : Symbol(u, Decl(awaited.ts, 65, 21))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>U : Symbol(U, Decl(awaited.ts, 65, 18))
+
+    return await u;
+>u : Symbol(u, Decl(awaited.ts, 65, 21))
+}
+
+// assignability
+let v0: number;
+>v0 : Symbol(v0, Decl(awaited.ts, 70, 3))
+
+let v1: awaited number;
+>v1 : Symbol(v1, Decl(awaited.ts, 71, 3))
+
+let v2: awaited Promise<number>;
+>v2 : Symbol(v2, Decl(awaited.ts, 72, 3))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+v0 = v1;
+>v0 : Symbol(v0, Decl(awaited.ts, 70, 3))
+>v1 : Symbol(v1, Decl(awaited.ts, 71, 3))
+
+v0 = v2;
+>v0 : Symbol(v0, Decl(awaited.ts, 70, 3))
+>v2 : Symbol(v2, Decl(awaited.ts, 72, 3))
+
+v1 = v0;
+>v1 : Symbol(v1, Decl(awaited.ts, 71, 3))
+>v0 : Symbol(v0, Decl(awaited.ts, 70, 3))
+
+v1 = v2;
+>v1 : Symbol(v1, Decl(awaited.ts, 71, 3))
+>v2 : Symbol(v2, Decl(awaited.ts, 72, 3))
+
+v2 = v0;
+>v2 : Symbol(v2, Decl(awaited.ts, 72, 3))
+>v0 : Symbol(v0, Decl(awaited.ts, 70, 3))
+
+v2 = v1;
+>v2 : Symbol(v2, Decl(awaited.ts, 72, 3))
+>v1 : Symbol(v1, Decl(awaited.ts, 71, 3))
+
+function f7<U>() {
+>f7 : Symbol(f7, Decl(awaited.ts, 78, 8))
+>U : Symbol(U, Decl(awaited.ts, 80, 12))
+
+    let v0: awaited U;
+>v0 : Symbol(v0, Decl(awaited.ts, 81, 7))
+>U : Symbol(U, Decl(awaited.ts, 80, 12))
+
+    let v1: awaited Promise<U>;
+>v1 : Symbol(v1, Decl(awaited.ts, 82, 7))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>U : Symbol(U, Decl(awaited.ts, 80, 12))
+
+    v0 = v1;
+>v0 : Symbol(v0, Decl(awaited.ts, 81, 7))
+>v1 : Symbol(v1, Decl(awaited.ts, 82, 7))
+
+    v1 = v0;
+>v1 : Symbol(v1, Decl(awaited.ts, 82, 7))
+>v0 : Symbol(v0, Decl(awaited.ts, 81, 7))
+}
+
+async function f8<U>() {
+>f8 : Symbol(f8, Decl(awaited.ts, 85, 1))
+>U : Symbol(U, Decl(awaited.ts, 87, 18))
+
+    let pu: Promise<U>;
+>pu : Symbol(pu, Decl(awaited.ts, 88, 7))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>U : Symbol(U, Decl(awaited.ts, 87, 18))
+
+    let v0: awaited U;
+>v0 : Symbol(v0, Decl(awaited.ts, 89, 7))
+>U : Symbol(U, Decl(awaited.ts, 87, 18))
+
+    let v1: awaited Promise<U>;
+>v1 : Symbol(v1, Decl(awaited.ts, 90, 7))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>U : Symbol(U, Decl(awaited.ts, 87, 18))
+
+    v0 = await pu;
+>v0 : Symbol(v0, Decl(awaited.ts, 89, 7))
+>pu : Symbol(pu, Decl(awaited.ts, 88, 7))
+
+    v1 = await pu;
+>v1 : Symbol(v1, Decl(awaited.ts, 90, 7))
+>pu : Symbol(pu, Decl(awaited.ts, 88, 7))
+}
diff --git a/tests/baselines/reference/awaited.types b/tests/baselines/reference/awaited.types
new file mode 100644
index 0000000000000..0e2a30f89fd66
--- /dev/null
+++ b/tests/baselines/reference/awaited.types
@@ -0,0 +1,542 @@
+=== tests/cases/conformance/types/awaited/awaited.ts ===
+// simple
+declare const p0: Promise<number>;
+>p0 : Promise<number>
+>Promise : Promise<T>
+
+p0.then(x => x);
+>p0.then(x => x) : Promise<number>
+>p0.then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>p0 : Promise<number>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+declare const p1: Promise<Promise<number>>;
+>p1 : Promise<Promise<number>>
+>Promise : Promise<T>
+>Promise : Promise<T>
+
+p1.then(x => x);
+>p1.then(x => x) : Promise<number>
+>p1.then : <TResult1 = Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>p1 : Promise<Promise<number>>
+>then : <TResult1 = Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+declare const p2: Promise<number | Promise<number>>;
+>p2 : Promise<number | Promise<number>>
+>Promise : Promise<T>
+>Promise : Promise<T>
+
+p2.then(x => x);
+>p2.then(x => x) : Promise<number>
+>p2.then : <TResult1 = number | Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>p2 : Promise<number | Promise<number>>
+>then : <TResult1 = number | Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+// generics
+declare const f: boolean;
+>f : boolean
+
+declare function makePromise<T>(x: T): Promise<T>;
+>makePromise : <T>(x: T) => Promise<T>
+>T : T
+>x : T
+>T : T
+>Promise : Promise<T>
+>T : T
+
+makePromise(1).then(x => x);
+>makePromise(1).then(x => x) : Promise<number>
+>makePromise(1).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>makePromise(1) : Promise<number>
+>makePromise : <T>(x: T) => Promise<T>
+>1 : 1
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+makePromise("a").then(x => x);
+>makePromise("a").then(x => x) : Promise<string>
+>makePromise("a").then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>makePromise("a") : Promise<string>
+>makePromise : <T>(x: T) => Promise<T>
+>"a" : "a"
+>then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: string) => string
+>x : string
+>x : string
+
+makePromise({ a: 1 }).then(x => x);
+>makePromise({ a: 1 }).then(x => x) : Promise<{ a: number; }>
+>makePromise({ a: 1 }).then : <TResult1 = { a: number; }, TResult2 = never>(onfulfilled?: (value: { a: number; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>makePromise({ a: 1 }) : Promise<{ a: number; }>
+>makePromise : <T>(x: T) => Promise<T>
+>{ a: 1 } : { a: number; }
+>a : number
+>1 : 1
+>then : <TResult1 = { a: number; }, TResult2 = never>(onfulfilled?: (value: { a: number; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: { a: number; }) => { a: number; }
+>x : { a: number; }
+>x : { a: number; }
+
+makePromise(f ? 1 : "a").then(x => x);
+>makePromise(f ? 1 : "a").then(x => x) : Promise<string | number>
+>makePromise(f ? 1 : "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>makePromise(f ? 1 : "a") : Promise<string | number>
+>makePromise : <T>(x: T) => Promise<T>
+>f ? 1 : "a" : 1 | "a"
+>f : boolean
+>1 : 1
+>"a" : "a"
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: string | number) => string | number
+>x : string | number
+>x : string | number
+
+function f0<U>(u: U) {
+>f0 : <U>(u: U) => Promise<awaited U>
+>U : U
+>u : U
+>U : U
+
+    return makePromise(u).then(x => x);
+>makePromise(u).then(x => x) : Promise<awaited U>
+>makePromise(u).then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>makePromise(u) : Promise<U>
+>makePromise : <T>(x: T) => Promise<T>
+>u : U
+>then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: awaited U) => awaited U
+>x : awaited U
+>x : awaited U
+}
+f0(1).then(x => x);
+>f0(1).then(x => x) : Promise<number>
+>f0(1).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f0(1) : Promise<number>
+>f0 : <U>(u: U) => Promise<awaited U>
+>1 : 1
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+f0("a").then(x => x);
+>f0("a").then(x => x) : Promise<string>
+>f0("a").then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f0("a") : Promise<string>
+>f0 : <U>(u: U) => Promise<awaited U>
+>"a" : "a"
+>then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: string) => string
+>x : string
+>x : string
+
+f0(f ? 1 : "a").then(x => x);
+>f0(f ? 1 : "a").then(x => x) : Promise<string | number>
+>f0(f ? 1 : "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f0(f ? 1 : "a") : Promise<string | number>
+>f0 : <U>(u: U) => Promise<awaited U>
+>f ? 1 : "a" : 1 | "a"
+>f : boolean
+>1 : 1
+>"a" : "a"
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: string | number) => string | number
+>x : string | number
+>x : string | number
+
+f0(makePromise(1)).then(x => x);
+>f0(makePromise(1)).then(x => x) : Promise<number>
+>f0(makePromise(1)).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f0(makePromise(1)) : Promise<number>
+>f0 : <U>(u: U) => Promise<awaited U>
+>makePromise(1) : Promise<number>
+>makePromise : <T>(x: T) => Promise<T>
+>1 : 1
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+function f1<U, V>(u: U, v: V) {
+>f1 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
+>U : U
+>V : V
+>u : U
+>U : U
+>v : V
+>V : V
+
+    return makePromise(u).then(x => {
+>makePromise(u).then(x => {        if (f) return x;        return makePromise(v).then(x => x);    }) : Promise<awaited U | awaited V>
+>makePromise(u).then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>makePromise(u) : Promise<U>
+>makePromise : <T>(x: T) => Promise<T>
+>u : U
+>then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => {        if (f) return x;        return makePromise(v).then(x => x);    } : (x: awaited U) => awaited U | Promise<awaited V>
+>x : awaited U
+
+        if (f) return x;
+>f : boolean
+>x : awaited U
+
+        return makePromise(v).then(x => x);
+>makePromise(v).then(x => x) : Promise<awaited V>
+>makePromise(v).then : <TResult1 = V, TResult2 = never>(onfulfilled?: (value: awaited V) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>makePromise(v) : Promise<V>
+>makePromise : <T>(x: T) => Promise<T>
+>v : V
+>then : <TResult1 = V, TResult2 = never>(onfulfilled?: (value: awaited V) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: awaited V) => awaited V
+>x : awaited V
+>x : awaited V
+
+    });
+}
+f1(1, "a").then(x => x);
+>f1(1, "a").then(x => x) : Promise<string | number>
+>f1(1, "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f1(1, "a") : Promise<string | number>
+>f1 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
+>1 : 1
+>"a" : "a"
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: string | number) => string | number
+>x : string | number
+>x : string | number
+
+f1(makePromise(1), makePromise("a")).then(x => x);
+>f1(makePromise(1), makePromise("a")).then(x => x) : Promise<string | number>
+>f1(makePromise(1), makePromise("a")).then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f1(makePromise(1), makePromise("a")) : Promise<string | number>
+>f1 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
+>makePromise(1) : Promise<number>
+>makePromise : <T>(x: T) => Promise<T>
+>1 : 1
+>makePromise("a") : Promise<string>
+>makePromise : <T>(x: T) => Promise<T>
+>"a" : "a"
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: string | number) => string | number
+>x : string | number
+>x : string | number
+
+function f2<U>(u: U) {
+>f2 : <U>(u: U) => Promise<awaited U>
+>U : U
+>u : U
+>U : U
+
+    return makePromise(u).then(x => {
+>makePromise(u).then(x => {        if (f) return x;        return Promise.reject("b");    }) : Promise<awaited U>
+>makePromise(u).then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>makePromise(u) : Promise<U>
+>makePromise : <T>(x: T) => Promise<T>
+>u : U
+>then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => {        if (f) return x;        return Promise.reject("b");    } : (x: awaited U) => awaited U | Promise<never>
+>x : awaited U
+
+        if (f) return x;
+>f : boolean
+>x : awaited U
+
+        return Promise.reject("b");
+>Promise.reject("b") : Promise<never>
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
+>Promise : PromiseConstructor
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
+>"b" : "b"
+
+    });
+}
+f2(1).then(x => x);
+>f2(1).then(x => x) : Promise<number>
+>f2(1).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f2(1) : Promise<number>
+>f2 : <U>(u: U) => Promise<awaited U>
+>1 : 1
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+f2(makePromise(1)).then(x => x);
+>f2(makePromise(1)).then(x => x) : Promise<number>
+>f2(makePromise(1)).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f2(makePromise(1)) : Promise<number>
+>f2 : <U>(u: U) => Promise<awaited U>
+>makePromise(1) : Promise<number>
+>makePromise : <T>(x: T) => Promise<T>
+>1 : 1
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+function f3<U, V>(u: U, v: V) {
+>f3 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
+>U : U
+>V : V
+>u : U
+>U : U
+>v : V
+>V : V
+
+    return makePromise(u).catch(x => v);
+>makePromise(u).catch(x => v) : Promise<awaited U | awaited V>
+>makePromise(u).catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<awaited U | awaited TResult>
+>makePromise(u) : Promise<U>
+>makePromise : <T>(x: T) => Promise<T>
+>u : U
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<awaited U | awaited TResult>
+>x => v : (x: any) => V
+>x : any
+>v : V
+}
+f3(1, "a").then(x => x);
+>f3(1, "a").then(x => x) : Promise<string | number>
+>f3(1, "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f3(1, "a") : Promise<string | number>
+>f3 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
+>1 : 1
+>"a" : "a"
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: string | number) => string | number
+>x : string | number
+>x : string | number
+
+f3(makePromise(1), makePromise("a")).then(x => x);
+>f3(makePromise(1), makePromise("a")).then(x => x) : Promise<string | number>
+>f3(makePromise(1), makePromise("a")).then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f3(makePromise(1), makePromise("a")) : Promise<string | number>
+>f3 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
+>makePromise(1) : Promise<number>
+>makePromise : <T>(x: T) => Promise<T>
+>1 : 1
+>makePromise("a") : Promise<string>
+>makePromise : <T>(x: T) => Promise<T>
+>"a" : "a"
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: string | number) => string | number
+>x : string | number
+>x : string | number
+
+function f4<U, V>(u: U, v: V) {
+>f4 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
+>U : U
+>V : V
+>u : U
+>U : U
+>v : V
+>V : V
+
+    return makePromise(u).catch(x => {
+>makePromise(u).catch(x => {        if (f) return v;        return Promise.reject("b");    }) : Promise<awaited U | awaited V>
+>makePromise(u).catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<awaited U | awaited TResult>
+>makePromise(u) : Promise<U>
+>makePromise : <T>(x: T) => Promise<T>
+>u : U
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<awaited U | awaited TResult>
+>x => {        if (f) return v;        return Promise.reject("b");    } : (x: any) => Promise<never> | V
+>x : any
+
+        if (f) return v;
+>f : boolean
+>v : V
+
+        return Promise.reject("b");
+>Promise.reject("b") : Promise<never>
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
+>Promise : PromiseConstructor
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
+>"b" : "b"
+
+    });
+}
+f4(1, "a").then(x => x);
+>f4(1, "a").then(x => x) : Promise<string | number>
+>f4(1, "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f4(1, "a") : Promise<string | number>
+>f4 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
+>1 : 1
+>"a" : "a"
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: string | number) => string | number
+>x : string | number
+>x : string | number
+
+f4(makePromise(1), makePromise("a")).then(x => x);
+>f4(makePromise(1), makePromise("a")).then(x => x) : Promise<string | number>
+>f4(makePromise(1), makePromise("a")).then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f4(makePromise(1), makePromise("a")) : Promise<string | number>
+>f4 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
+>makePromise(1) : Promise<number>
+>makePromise : <T>(x: T) => Promise<T>
+>1 : 1
+>makePromise("a") : Promise<string>
+>makePromise : <T>(x: T) => Promise<T>
+>"a" : "a"
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: string | number) => string | number
+>x : string | number
+>x : string | number
+
+async function f5<U>(u: Promise<U>) {
+>f5 : <U>(u: Promise<U>) => Promise<awaited U>
+>U : U
+>u : Promise<U>
+>Promise : Promise<T>
+>U : U
+
+    return await u;
+>await u : awaited U
+>u : Promise<U>
+}
+f5(makePromise(1)).then(x => x);
+>f5(makePromise(1)).then(x => x) : Promise<number>
+>f5(makePromise(1)).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f5(makePromise(1)) : Promise<number>
+>f5 : <U>(u: Promise<U>) => Promise<awaited U>
+>makePromise(1) : Promise<number>
+>makePromise : <T>(x: T) => Promise<T>
+>1 : 1
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+f5(makePromise(makePromise(1))).then(x => x);
+>f5(makePromise(makePromise(1))).then(x => x) : Promise<number>
+>f5(makePromise(makePromise(1))).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>f5(makePromise(makePromise(1))) : Promise<number>
+>f5 : <U>(u: Promise<U>) => Promise<awaited U>
+>makePromise(makePromise(1)) : Promise<Promise<number>>
+>makePromise : <T>(x: T) => Promise<T>
+>makePromise(1) : Promise<number>
+>makePromise : <T>(x: T) => Promise<T>
+>1 : 1
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+async function f6<U>(u: Promise<Promise<U>>) {
+>f6 : <U>(u: Promise<Promise<U>>) => Promise<awaited U>
+>U : U
+>u : Promise<Promise<U>>
+>Promise : Promise<T>
+>Promise : Promise<T>
+>U : U
+
+    return await u;
+>await u : awaited U
+>u : Promise<Promise<U>>
+}
+
+// assignability
+let v0: number;
+>v0 : number
+
+let v1: awaited number;
+>v1 : number
+
+let v2: awaited Promise<number>;
+>v2 : number
+>Promise : Promise<T>
+
+v0 = v1;
+>v0 = v1 : number
+>v0 : number
+>v1 : number
+
+v0 = v2;
+>v0 = v2 : number
+>v0 : number
+>v2 : number
+
+v1 = v0;
+>v1 = v0 : number
+>v1 : number
+>v0 : number
+
+v1 = v2;
+>v1 = v2 : number
+>v1 : number
+>v2 : number
+
+v2 = v0;
+>v2 = v0 : number
+>v2 : number
+>v0 : number
+
+v2 = v1;
+>v2 = v1 : number
+>v2 : number
+>v1 : number
+
+function f7<U>() {
+>f7 : <U>() => void
+>U : U
+
+    let v0: awaited U;
+>v0 : awaited U
+>U : U
+
+    let v1: awaited Promise<U>;
+>v1 : awaited U
+>Promise : Promise<T>
+>U : U
+
+    v0 = v1;
+>v0 = v1 : awaited U
+>v0 : awaited U
+>v1 : awaited U
+
+    v1 = v0;
+>v1 = v0 : awaited U
+>v1 : awaited U
+>v0 : awaited U
+}
+
+async function f8<U>() {
+>f8 : <U>() => Promise<void>
+>U : U
+
+    let pu: Promise<U>;
+>pu : Promise<U>
+>Promise : Promise<T>
+>U : U
+
+    let v0: awaited U;
+>v0 : awaited U
+>U : U
+
+    let v1: awaited Promise<U>;
+>v1 : awaited U
+>Promise : Promise<T>
+>U : U
+
+    v0 = await pu;
+>v0 = await pu : awaited U
+>v0 : awaited U
+>await pu : awaited U
+>pu : Promise<U>
+
+    v1 = await pu;
+>v1 = await pu : awaited U
+>v1 : awaited U
+>await pu : awaited U
+>pu : Promise<U>
+}
diff --git a/tests/baselines/reference/correctOrderOfPromiseMethod.types b/tests/baselines/reference/correctOrderOfPromiseMethod.types
index fb4843bd3f1f1..a7ee9d1e73f00 100644
--- a/tests/baselines/reference/correctOrderOfPromiseMethod.types
+++ b/tests/baselines/reference/correctOrderOfPromiseMethod.types
@@ -39,9 +39,9 @@ async function countEverything(): Promise<number> {
 >resultB : B[]
 >await Promise.all([        providerA(),        providerB(),    ]) : [A[], B[]]
 >Promise.all([        providerA(),        providerB(),    ]) : Promise<[A[], B[]]>
->Promise.all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; }
+>Promise.all : { <TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9, awaited T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: T[]): Promise<(awaited T)[]>; }
 >Promise : PromiseConstructor
->all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; }
+>all : { <TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9, awaited T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: T[]): Promise<(awaited T)[]>; }
 >[        providerA(),        providerB(),    ] : [Promise<A[]>, Promise<B[]>]
 
         providerA(),
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.types b/tests/baselines/reference/exportDefaultAsyncFunction2.types
index 9aad9fb98ec89..601ebb45a95de 100644
--- a/tests/baselines/reference/exportDefaultAsyncFunction2.types
+++ b/tests/baselines/reference/exportDefaultAsyncFunction2.types
@@ -20,9 +20,9 @@ export default async(() => await(Promise.resolve(1)));
 >await(Promise.resolve(1)) : any
 >await : (...args: any[]) => any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 === tests/cases/compiler/b.ts ===
diff --git a/tests/baselines/reference/importCallExpression1ESNext.types b/tests/baselines/reference/importCallExpression1ESNext.types
index 29e2c3d261bc9..ab3aed8dc7a03 100644
--- a/tests/baselines/reference/importCallExpression1ESNext.types
+++ b/tests/baselines/reference/importCallExpression1ESNext.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpression2ESNext.types b/tests/baselines/reference/importCallExpression2ESNext.types
index 084eb33dde95d..ae71327fd7ae1 100644
--- a/tests/baselines/reference/importCallExpression2ESNext.types
+++ b/tests/baselines/reference/importCallExpression2ESNext.types
@@ -15,9 +15,9 @@ function foo(x: Promise<any>) {
 
     x.then(value => {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
->x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >value : any
 
diff --git a/tests/baselines/reference/importCallExpression4ESNext.types b/tests/baselines/reference/importCallExpression4ESNext.types
index 74cc6ff8b28fa..17735c793cd17 100644
--- a/tests/baselines/reference/importCallExpression4ESNext.types
+++ b/tests/baselines/reference/importCallExpression4ESNext.types
@@ -38,11 +38,11 @@ class C {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES5AMD.types b/tests/baselines/reference/importCallExpressionES5AMD.types
index e97f722b14ff5..82fd2046775c1 100644
--- a/tests/baselines/reference/importCallExpressionES5AMD.types
+++ b/tests/baselines/reference/importCallExpressionES5AMD.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES5CJS.types b/tests/baselines/reference/importCallExpressionES5CJS.types
index e97f722b14ff5..82fd2046775c1 100644
--- a/tests/baselines/reference/importCallExpressionES5CJS.types
+++ b/tests/baselines/reference/importCallExpressionES5CJS.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES5System.types b/tests/baselines/reference/importCallExpressionES5System.types
index 02bd64142d499..e38046f93aa1f 100644
--- a/tests/baselines/reference/importCallExpressionES5System.types
+++ b/tests/baselines/reference/importCallExpressionES5System.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }
 
diff --git a/tests/baselines/reference/importCallExpressionES5UMD.types b/tests/baselines/reference/importCallExpressionES5UMD.types
index e97f722b14ff5..82fd2046775c1 100644
--- a/tests/baselines/reference/importCallExpressionES5UMD.types
+++ b/tests/baselines/reference/importCallExpressionES5UMD.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES6AMD.types b/tests/baselines/reference/importCallExpressionES6AMD.types
index e97f722b14ff5..82fd2046775c1 100644
--- a/tests/baselines/reference/importCallExpressionES6AMD.types
+++ b/tests/baselines/reference/importCallExpressionES6AMD.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES6CJS.types b/tests/baselines/reference/importCallExpressionES6CJS.types
index e97f722b14ff5..82fd2046775c1 100644
--- a/tests/baselines/reference/importCallExpressionES6CJS.types
+++ b/tests/baselines/reference/importCallExpressionES6CJS.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES6System.types b/tests/baselines/reference/importCallExpressionES6System.types
index 02bd64142d499..e38046f93aa1f 100644
--- a/tests/baselines/reference/importCallExpressionES6System.types
+++ b/tests/baselines/reference/importCallExpressionES6System.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }
 
diff --git a/tests/baselines/reference/importCallExpressionES6UMD.types b/tests/baselines/reference/importCallExpressionES6UMD.types
index e97f722b14ff5..82fd2046775c1 100644
--- a/tests/baselines/reference/importCallExpressionES6UMD.types
+++ b/tests/baselines/reference/importCallExpressionES6UMD.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInAMD1.types b/tests/baselines/reference/importCallExpressionInAMD1.types
index 661d27d14692e..826be9a4caa63 100644
--- a/tests/baselines/reference/importCallExpressionInAMD1.types
+++ b/tests/baselines/reference/importCallExpressionInAMD1.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInAMD2.types b/tests/baselines/reference/importCallExpressionInAMD2.types
index 44b17eb51fd5c..f950485f685b5 100644
--- a/tests/baselines/reference/importCallExpressionInAMD2.types
+++ b/tests/baselines/reference/importCallExpressionInAMD2.types
@@ -16,9 +16,9 @@ function foo(x: Promise<any>) {
 
     x.then(value => {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
->x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >value : any
 
diff --git a/tests/baselines/reference/importCallExpressionInAMD4.types b/tests/baselines/reference/importCallExpressionInAMD4.types
index 156247851c914..033fb0c32e36a 100644
--- a/tests/baselines/reference/importCallExpressionInAMD4.types
+++ b/tests/baselines/reference/importCallExpressionInAMD4.types
@@ -38,11 +38,11 @@ class C {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
@@ -105,11 +105,11 @@ export class D {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInCJS1.types b/tests/baselines/reference/importCallExpressionInCJS1.types
index 661d27d14692e..826be9a4caa63 100644
--- a/tests/baselines/reference/importCallExpressionInCJS1.types
+++ b/tests/baselines/reference/importCallExpressionInCJS1.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInCJS3.types b/tests/baselines/reference/importCallExpressionInCJS3.types
index 44b17eb51fd5c..f950485f685b5 100644
--- a/tests/baselines/reference/importCallExpressionInCJS3.types
+++ b/tests/baselines/reference/importCallExpressionInCJS3.types
@@ -16,9 +16,9 @@ function foo(x: Promise<any>) {
 
     x.then(value => {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
->x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >value : any
 
diff --git a/tests/baselines/reference/importCallExpressionInCJS5.types b/tests/baselines/reference/importCallExpressionInCJS5.types
index 7d0c6f01cacd3..e36556236c246 100644
--- a/tests/baselines/reference/importCallExpressionInCJS5.types
+++ b/tests/baselines/reference/importCallExpressionInCJS5.types
@@ -38,11 +38,11 @@ class C {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
@@ -105,11 +105,11 @@ export class D {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInSystem1.types b/tests/baselines/reference/importCallExpressionInSystem1.types
index a82d817675388..6a73cbcacc9e7 100644
--- a/tests/baselines/reference/importCallExpressionInSystem1.types
+++ b/tests/baselines/reference/importCallExpressionInSystem1.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }
 
diff --git a/tests/baselines/reference/importCallExpressionInSystem2.types b/tests/baselines/reference/importCallExpressionInSystem2.types
index 160da81b214fb..cfbeb5ff5ce28 100644
--- a/tests/baselines/reference/importCallExpressionInSystem2.types
+++ b/tests/baselines/reference/importCallExpressionInSystem2.types
@@ -16,9 +16,9 @@ function foo(x: Promise<any>) {
 
     x.then(value => {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
->x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >value : any
 
diff --git a/tests/baselines/reference/importCallExpressionInSystem4.types b/tests/baselines/reference/importCallExpressionInSystem4.types
index c9f2b2e5211ac..db416f42bd78a 100644
--- a/tests/baselines/reference/importCallExpressionInSystem4.types
+++ b/tests/baselines/reference/importCallExpressionInSystem4.types
@@ -38,11 +38,11 @@ class C {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }
 
@@ -105,11 +105,11 @@ export class D {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }
 
diff --git a/tests/baselines/reference/importCallExpressionInUMD1.types b/tests/baselines/reference/importCallExpressionInUMD1.types
index 661d27d14692e..826be9a4caa63 100644
--- a/tests/baselines/reference/importCallExpressionInUMD1.types
+++ b/tests/baselines/reference/importCallExpressionInUMD1.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInUMD2.types b/tests/baselines/reference/importCallExpressionInUMD2.types
index 44b17eb51fd5c..f950485f685b5 100644
--- a/tests/baselines/reference/importCallExpressionInUMD2.types
+++ b/tests/baselines/reference/importCallExpressionInUMD2.types
@@ -16,9 +16,9 @@ function foo(x: Promise<any>) {
 
     x.then(value => {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
->x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >value : any
 
diff --git a/tests/baselines/reference/importCallExpressionInUMD4.types b/tests/baselines/reference/importCallExpressionInUMD4.types
index 156247851c914..033fb0c32e36a 100644
--- a/tests/baselines/reference/importCallExpressionInUMD4.types
+++ b/tests/baselines/reference/importCallExpressionInUMD4.types
@@ -38,11 +38,11 @@ class C {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
@@ -105,11 +105,11 @@ export class D {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
index fc52b38c1fb9f..060a24a81b386 100644
--- a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
+++ b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
@@ -69,9 +69,9 @@ const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();  // ok, zero is any}) : Promise<any>
->p1.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();  // ok, zero is any} : (zero: any) => any
 >zero : any
 
diff --git a/tests/baselines/reference/importCallExpressionShouldNotGetParen.types b/tests/baselines/reference/importCallExpressionShouldNotGetParen.types
index 3e4001dc5b710..4cde8976b4398 100644
--- a/tests/baselines/reference/importCallExpressionShouldNotGetParen.types
+++ b/tests/baselines/reference/importCallExpressionShouldNotGetParen.types
@@ -5,11 +5,11 @@ const localeName = "zh-CN";
 
 import(`./locales/${localeName}.js`).then(bar => {
 >import(`./locales/${localeName}.js`).then(bar => {    let x = bar;}) : Promise<void>
->import(`./locales/${localeName}.js`).then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>import(`./locales/${localeName}.js`).then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >import(`./locales/${localeName}.js`) : Promise<any>
 >`./locales/${localeName}.js` : string
 >localeName : "zh-CN"
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >bar => {    let x = bar;} : (bar: any) => void
 >bar : any
 
@@ -21,14 +21,14 @@ import(`./locales/${localeName}.js`).then(bar => {
 
 import("./locales/" + localeName + ".js").then(bar => {
 >import("./locales/" + localeName + ".js").then(bar => {    let x = bar;}) : Promise<void>
->import("./locales/" + localeName + ".js").then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>import("./locales/" + localeName + ".js").then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >import("./locales/" + localeName + ".js") : Promise<any>
 >"./locales/" + localeName + ".js" : string
 >"./locales/" + localeName : string
 >"./locales/" : "./locales/"
 >localeName : "zh-CN"
 >".js" : ".js"
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >bar => {    let x = bar;} : (bar: any) => void
 >bar : any
 
diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types
index 4a3989322322b..b117371a6ac42 100644
--- a/tests/baselines/reference/inferenceLimit.types
+++ b/tests/baselines/reference/inferenceLimit.types
@@ -46,7 +46,7 @@ export class BrokenClass {
 
         this.doStuff(order.id)
 >this.doStuff(order.id)          .then((items) => {            order.items = items;            resolve(order);          }) : Promise<void>
->this.doStuff(order.id)          .then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.doStuff(order.id)          .then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.doStuff(order.id) : Promise<void>
 >this.doStuff : (id: number) => Promise<void>
 >this : this
@@ -56,7 +56,7 @@ export class BrokenClass {
 >id : any
 
           .then((items) => {
->then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >(items) => {            order.items = items;            resolve(order);          } : (items: void) => void
 >items : void
 
@@ -78,11 +78,11 @@ export class BrokenClass {
 
     return Promise.all(result.map(populateItems))
 >Promise.all(result.map(populateItems))      .then((orders: Array<MyModule.MyModel>) => {        resolve(orders);      }) : Promise<void>
->Promise.all(result.map(populateItems))      .then : <TResult1 = {}[], TResult2 = never>(onfulfilled?: (value: {}[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>Promise.all(result.map(populateItems))      .then : <TResult1 = {}[], TResult2 = never>(onfulfilled?: (value: {}[]) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Promise.all(result.map(populateItems)) : Promise<{}[]>
->Promise.all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; }
+>Promise.all : { <TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9, awaited T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: T[]): Promise<(awaited T)[]>; }
 >Promise : PromiseConstructor
->all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; }
+>all : { <TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9, awaited T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: T[]): Promise<(awaited T)[]>; }
 >result.map(populateItems) : Promise<{}>[]
 >result.map : <U>(callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
 >result : MyModule.MyModel[]
@@ -90,7 +90,7 @@ export class BrokenClass {
 >populateItems : (order: any) => Promise<{}>
 
       .then((orders: Array<MyModule.MyModel>) => {
->then : <TResult1 = {}[], TResult2 = never>(onfulfilled?: (value: {}[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = {}[], TResult2 = never>(onfulfilled?: (value: {}[]) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >(orders: Array<MyModule.MyModel>) => {        resolve(orders);      } : (orders: MyModule.MyModel[]) => void
 >orders : MyModule.MyModel[]
 >Array : T[]
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
index a77fcd223f4dd..5ca7772ed4737 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
@@ -147,10 +147,10 @@ declare var console: any;
 
 out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
->out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >out() : Promise<{}>
 >out : () => Promise<{}>
->then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {    console.log("Yea!");} : () => void
 
     console.log("Yea!");
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
index 6d5770659dec4..40d3d8db01951 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
@@ -147,10 +147,10 @@ declare var console: any;
 
 out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
->out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >out() : Promise<{}>
 >out : () => Promise<{}>
->then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {    console.log("Yea!");} : () => void
 
     console.log("Yea!");
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
index 9ca65cb9583c4..4a75e812f976c 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
@@ -147,10 +147,10 @@ declare var console: any;
 
 out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
->out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >out() : Promise<{}>
 >out : () => Promise<{}>
->then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {    console.log("Yea!");} : () => void
 
     console.log("Yea!");
diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.types b/tests/baselines/reference/noImplicitReturnsInAsync1.types
index dd468d33e6e21..6057400549381 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 : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"The test is passed without an error." : "The test is passed without an error."
 }
diff --git a/tests/baselines/reference/promisePermutations.errors.txt b/tests/baselines/reference/promisePermutations.errors.txt
index a876345ffa100..46cca3191d0db 100644
--- a/tests/baselines/reference/promisePermutations.errors.txt
+++ b/tests/baselines/reference/promisePermutations.errors.txt
@@ -49,7 +49,7 @@ tests/cases/compiler/promisePermutations.ts(144,35): error TS2345: Argument of t
 tests/cases/compiler/promisePermutations.ts(152,36): error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
     Types of property 'then' are incompatible.
-      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
         Types of parameters 'success' and 'onfulfilled' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'string' is not assignable to type 'number'.
@@ -64,7 +64,7 @@ tests/cases/compiler/promisePermutations.ts(159,21): error TS2345: Argument of t
 tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
         Types of parameters 'onfulfilled' and 'success' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'number' is not assignable to type 'string'.
@@ -303,7 +303,7 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of t
 !!! error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
 !!! error TS2345:   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2345:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
 !!! error TS2345:         Types of parameters 'success' and 'onfulfilled' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'string' is not assignable to type 'number'.
@@ -330,7 +330,7 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of t
 !!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 !!! error TS2345:   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
 !!! error TS2345:         Types of parameters 'onfulfilled' and 'success' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'number' is not assignable to type 'string'.
diff --git a/tests/baselines/reference/promisePermutations2.errors.txt b/tests/baselines/reference/promisePermutations2.errors.txt
index 871ee2ae2c347..767d48de30bcd 100644
--- a/tests/baselines/reference/promisePermutations2.errors.txt
+++ b/tests/baselines/reference/promisePermutations2.errors.txt
@@ -49,7 +49,7 @@ tests/cases/compiler/promisePermutations2.ts(143,35): error TS2345: Argument of
 tests/cases/compiler/promisePermutations2.ts(151,36): error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
     Types of property 'then' are incompatible.
-      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
         Types of parameters 'success' and 'onfulfilled' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'string' is not assignable to type 'number'.
@@ -64,7 +64,7 @@ tests/cases/compiler/promisePermutations2.ts(158,21): error TS2345: Argument of
 tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
         Types of parameters 'onfulfilled' and 'success' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'number' is not assignable to type 'string'.
@@ -302,7 +302,7 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
 !!! error TS2345:   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2345:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
 !!! error TS2345:         Types of parameters 'success' and 'onfulfilled' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'string' is not assignable to type 'number'.
@@ -329,7 +329,7 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 !!! error TS2345:   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
 !!! error TS2345:         Types of parameters 'onfulfilled' and 'success' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'number' is not assignable to type 'string'.
diff --git a/tests/baselines/reference/promisePermutations3.errors.txt b/tests/baselines/reference/promisePermutations3.errors.txt
index 9d09559c5d32e..73917b6766993 100644
--- a/tests/baselines/reference/promisePermutations3.errors.txt
+++ b/tests/baselines/reference/promisePermutations3.errors.txt
@@ -52,7 +52,7 @@ tests/cases/compiler/promisePermutations3.ts(143,35): error TS2345: Argument of
 tests/cases/compiler/promisePermutations3.ts(151,36): error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
     Types of property 'then' are incompatible.
-      Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+      Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
         Types of parameters 'success' and 'onfulfilled' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'string' is not assignable to type 'number'.
@@ -67,14 +67,14 @@ tests/cases/compiler/promisePermutations3.ts(158,21): error TS2345: Argument of
 tests/cases/compiler/promisePermutations3.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
+      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
         Types of parameters 'onfulfilled' and 'success' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'number' is not assignable to type 'string'.
 tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of type '{ <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }' is not assignable to parameter of type '(value: (x: any) => any) => Promise<any>'.
   Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
     Types of property 'then' are incompatible.
-      Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+      Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
         Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
 
 
@@ -314,7 +314,7 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
 !!! error TS2345:   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2345:       Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
 !!! error TS2345:         Types of parameters 'success' and 'onfulfilled' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'string' is not assignable to type 'number'.
@@ -341,7 +341,7 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 !!! error TS2345:   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
+!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
 !!! error TS2345:         Types of parameters 'onfulfilled' and 'success' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'number' is not assignable to type 'string'.
@@ -355,6 +355,6 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '{ <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }' is not assignable to parameter of type '(value: (x: any) => any) => Promise<any>'.
 !!! error TS2345:   Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2345:       Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
 !!! error TS2345:         Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
     var s12c = s12.then(testFunction12P, testFunction12, testFunction12); // ok
\ No newline at end of file
diff --git a/tests/baselines/reference/promiseTest.types b/tests/baselines/reference/promiseTest.types
index b9166a1af25d4..4a86cea699455 100644
--- a/tests/baselines/reference/promiseTest.types
+++ b/tests/baselines/reference/promiseTest.types
@@ -4,7 +4,7 @@ interface Promise<T> {
 >T : T
 
     then<A>(success?: (value: T) => Promise<A>): Promise<A>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
 >A : A
 >success : (value: T) => Promise<A>
 >value : T
@@ -15,7 +15,7 @@ interface Promise<T> {
 >A : A
 
     then<B>(success?: (value: T) => B): Promise<B>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
 >B : B
 >success : (value: T) => B
 >value : T
@@ -37,9 +37,9 @@ var p: Promise<number> = null;
 var p2 = p.then(function (x) {
 >p2 : Promise<number>
 >p.then(function (x) {    return p;} ) : Promise<number>
->p.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
+>p.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
 >p : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
+>then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
 >function (x) {    return p;} : (x: number) => Promise<number>
 >x : number
 
diff --git a/tests/baselines/reference/promiseType.types b/tests/baselines/reference/promiseType.types
index 3228d266319f5..bc4ed1c18b928 100644
--- a/tests/baselines/reference/promiseType.types
+++ b/tests/baselines/reference/promiseType.types
@@ -105,9 +105,9 @@ async function F() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -170,9 +170,9 @@ async function I() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -183,231 +183,231 @@ async function I() {
 const p00 = p.catch();
 >p00 : Promise<boolean>
 >p.catch() : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 
 const p01 = p.then();
 >p01 : Promise<boolean>
 >p.then() : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 
 const p10 = p.catch(undefined);
 >p10 : Promise<boolean>
 >p.catch(undefined) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >undefined : undefined
 
 const p11 = p.catch(null);
 >p11 : Promise<boolean>
 >p.catch(null) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >null : null
 
 const p12 = p.catch(() => 1);
 >p12 : Promise<number | boolean>
 >p.catch(() => 1) : Promise<number | boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => 1 : () => number
 >1 : 1
 
 const p13 = p.catch(() => x);
 >p13 : Promise<any>
 >p.catch(() => x) : Promise<any>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => x : () => any
 >x : any
 
 const p14 = p.catch(() => undefined);
 >p14 : Promise<any>
 >p.catch(() => undefined) : Promise<any>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => undefined : () => any
 >undefined : undefined
 
 const p15 = p.catch(() => null);
 >p15 : Promise<any>
 >p.catch(() => null) : Promise<any>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => null : () => any
 >null : null
 
 const p16 = p.catch(() => {});
 >p16 : Promise<boolean | void>
 >p.catch(() => {}) : Promise<boolean | void>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => {} : () => void
 
 const p17 = p.catch(() => {throw 1});
 >p17 : Promise<boolean>
 >p.catch(() => {throw 1}) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => {throw 1} : () => never
 >1 : 1
 
 const p18 = p.catch(() => Promise.reject(1));
 >p18 : Promise<boolean>
 >p.catch(() => Promise.reject(1)) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p19 = p.catch(() => Promise.resolve(1));
 >p19 : Promise<number | boolean>
 >p.catch(() => Promise.resolve(1)) : Promise<number | boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p20 = p.then(undefined);
 >p20 : Promise<boolean>
 >p.then(undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 
 const p21 = p.then(null);
 >p21 : Promise<boolean>
 >p.then(null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 
 const p22 = p.then(() => 1);
 >p22 : Promise<number>
 >p.then(() => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => 1 : () => number
 >1 : 1
 
 const p23 = p.then(() => x);
 >p23 : Promise<any>
 >p.then(() => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 
 const p24 = p.then(() => undefined);
 >p24 : Promise<any>
 >p.then(() => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 
 const p25 = p.then(() => null);
 >p25 : Promise<any>
 >p.then(() => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 
 const p26 = p.then(() => {});
 >p26 : Promise<void>
 >p.then(() => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 
 const p27 = p.then(() => {throw 1});
 >p27 : Promise<never>
 >p.then(() => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 
 const p28 = p.then(() => Promise.resolve(1));
 >p28 : Promise<number>
 >p.then(() => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p29 = p.then(() => Promise.reject(1));
 >p29 : Promise<never>
 >p.then(() => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p30 = p.then(undefined, undefined);
 >p30 : Promise<boolean>
 >p.then(undefined, undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >undefined : undefined
 
 const p31 = p.then(undefined, null);
 >p31 : Promise<boolean>
 >p.then(undefined, null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >null : null
 
 const p32 = p.then(undefined, () => 1);
 >p32 : Promise<number | boolean>
 >p.then(undefined, () => 1) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => 1 : () => number
 >1 : 1
@@ -415,9 +415,9 @@ const p32 = p.then(undefined, () => 1);
 const p33 = p.then(undefined, () => x);
 >p33 : Promise<any>
 >p.then(undefined, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => x : () => any
 >x : any
@@ -425,9 +425,9 @@ const p33 = p.then(undefined, () => x);
 const p34 = p.then(undefined, () => undefined);
 >p34 : Promise<any>
 >p.then(undefined, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => undefined : () => any
 >undefined : undefined
@@ -435,9 +435,9 @@ const p34 = p.then(undefined, () => undefined);
 const p35 = p.then(undefined, () => null);
 >p35 : Promise<any>
 >p.then(undefined, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => null : () => any
 >null : null
@@ -445,18 +445,18 @@ const p35 = p.then(undefined, () => null);
 const p36 = p.then(undefined, () => {});
 >p36 : Promise<boolean | void>
 >p.then(undefined, () => {}) : Promise<boolean | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => {} : () => void
 
 const p37 = p.then(undefined, () => {throw 1});
 >p37 : Promise<boolean>
 >p.then(undefined, () => {throw 1}) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => {throw 1} : () => never
 >1 : 1
@@ -464,55 +464,55 @@ const p37 = p.then(undefined, () => {throw 1});
 const p38 = p.then(undefined, () => Promise.resolve(1));
 >p38 : Promise<number | boolean>
 >p.then(undefined, () => Promise.resolve(1)) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p39 = p.then(undefined, () => Promise.reject(1));
 >p39 : Promise<boolean>
 >p.then(undefined, () => Promise.reject(1)) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p40 = p.then(null, undefined);
 >p40 : Promise<boolean>
 >p.then(null, undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >undefined : undefined
 
 const p41 = p.then(null, null);
 >p41 : Promise<boolean>
 >p.then(null, null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >null : null
 
 const p42 = p.then(null, () => 1);
 >p42 : Promise<number | boolean>
 >p.then(null, () => 1) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => 1 : () => number
 >1 : 1
@@ -520,9 +520,9 @@ const p42 = p.then(null, () => 1);
 const p43 = p.then(null, () => x);
 >p43 : Promise<any>
 >p.then(null, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => x : () => any
 >x : any
@@ -530,9 +530,9 @@ const p43 = p.then(null, () => x);
 const p44 = p.then(null, () => undefined);
 >p44 : Promise<any>
 >p.then(null, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => undefined : () => any
 >undefined : undefined
@@ -540,9 +540,9 @@ const p44 = p.then(null, () => undefined);
 const p45 = p.then(null, () => null);
 >p45 : Promise<any>
 >p.then(null, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => null : () => any
 >null : null
@@ -550,18 +550,18 @@ const p45 = p.then(null, () => null);
 const p46 = p.then(null, () => {});
 >p46 : Promise<boolean | void>
 >p.then(null, () => {}) : Promise<boolean | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => {} : () => void
 
 const p47 = p.then(null, () => {throw 1});
 >p47 : Promise<boolean>
 >p.then(null, () => {throw 1}) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => {throw 1} : () => never
 >1 : 1
@@ -569,37 +569,37 @@ const p47 = p.then(null, () => {throw 1});
 const p48 = p.then(null, () => Promise.resolve(1));
 >p48 : Promise<number | boolean>
 >p.then(null, () => Promise.resolve(1)) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p49 = p.then(null, () => Promise.reject(1));
 >p49 : Promise<boolean>
 >p.then(null, () => Promise.reject(1)) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p50 = p.then(() => "1", undefined);
 >p50 : Promise<string>
 >p.then(() => "1", undefined) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >undefined : undefined
@@ -607,9 +607,9 @@ const p50 = p.then(() => "1", undefined);
 const p51 = p.then(() => "1", null);
 >p51 : Promise<string>
 >p.then(() => "1", null) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >null : null
@@ -617,9 +617,9 @@ const p51 = p.then(() => "1", null);
 const p52 = p.then(() => "1", () => 1);
 >p52 : Promise<string | number>
 >p.then(() => "1", () => 1) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => 1 : () => number
@@ -628,9 +628,9 @@ const p52 = p.then(() => "1", () => 1);
 const p53 = p.then(() => "1", () => x);
 >p53 : Promise<any>
 >p.then(() => "1", () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => x : () => any
@@ -639,9 +639,9 @@ const p53 = p.then(() => "1", () => x);
 const p54 = p.then(() => "1", () => undefined);
 >p54 : Promise<any>
 >p.then(() => "1", () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => undefined : () => any
@@ -650,9 +650,9 @@ const p54 = p.then(() => "1", () => undefined);
 const p55 = p.then(() => "1", () => null);
 >p55 : Promise<any>
 >p.then(() => "1", () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => null : () => any
@@ -661,9 +661,9 @@ const p55 = p.then(() => "1", () => null);
 const p56 = p.then(() => "1", () => {});
 >p56 : Promise<string | void>
 >p.then(() => "1", () => {}) : Promise<string | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => {} : () => void
@@ -671,9 +671,9 @@ const p56 = p.then(() => "1", () => {});
 const p57 = p.then(() => "1", () => {throw 1});
 >p57 : Promise<string>
 >p.then(() => "1", () => {throw 1}) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => {throw 1} : () => never
@@ -682,39 +682,39 @@ const p57 = p.then(() => "1", () => {throw 1});
 const p58 = p.then(() => "1", () => Promise.resolve(1));
 >p58 : Promise<string | number>
 >p.then(() => "1", () => Promise.resolve(1)) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p59 = p.then(() => "1", () => Promise.reject(1));
 >p59 : Promise<string>
 >p.then(() => "1", () => Promise.reject(1)) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p60 = p.then(() => x, undefined);
 >p60 : Promise<any>
 >p.then(() => x, undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >undefined : undefined
@@ -722,9 +722,9 @@ const p60 = p.then(() => x, undefined);
 const p61 = p.then(() => x, null);
 >p61 : Promise<any>
 >p.then(() => x, null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >null : null
@@ -732,9 +732,9 @@ const p61 = p.then(() => x, null);
 const p62 = p.then(() => x, () => 1);
 >p62 : Promise<any>
 >p.then(() => x, () => 1) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => 1 : () => number
@@ -743,9 +743,9 @@ const p62 = p.then(() => x, () => 1);
 const p63 = p.then(() => x, () => x);
 >p63 : Promise<any>
 >p.then(() => x, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => x : () => any
@@ -754,9 +754,9 @@ const p63 = p.then(() => x, () => x);
 const p64 = p.then(() => x, () => undefined);
 >p64 : Promise<any>
 >p.then(() => x, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => undefined : () => any
@@ -765,9 +765,9 @@ const p64 = p.then(() => x, () => undefined);
 const p65 = p.then(() => x, () => null);
 >p65 : Promise<any>
 >p.then(() => x, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => null : () => any
@@ -776,9 +776,9 @@ const p65 = p.then(() => x, () => null);
 const p66 = p.then(() => x, () => {});
 >p66 : Promise<any>
 >p.then(() => x, () => {}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => {} : () => void
@@ -786,9 +786,9 @@ const p66 = p.then(() => x, () => {});
 const p67 = p.then(() => x, () => {throw 1});
 >p67 : Promise<any>
 >p.then(() => x, () => {throw 1}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => {throw 1} : () => never
@@ -797,39 +797,39 @@ const p67 = p.then(() => x, () => {throw 1});
 const p68 = p.then(() => x, () => Promise.resolve(1));
 >p68 : Promise<any>
 >p.then(() => x, () => Promise.resolve(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p69 = p.then(() => x, () => Promise.reject(1));
 >p69 : Promise<any>
 >p.then(() => x, () => Promise.reject(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p70 = p.then(() => undefined, undefined);
 >p70 : Promise<any>
 >p.then(() => undefined, undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >undefined : undefined
@@ -837,9 +837,9 @@ const p70 = p.then(() => undefined, undefined);
 const p71 = p.then(() => undefined, null);
 >p71 : Promise<any>
 >p.then(() => undefined, null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >null : null
@@ -847,9 +847,9 @@ const p71 = p.then(() => undefined, null);
 const p72 = p.then(() => undefined, () => 1);
 >p72 : Promise<any>
 >p.then(() => undefined, () => 1) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => 1 : () => number
@@ -858,9 +858,9 @@ const p72 = p.then(() => undefined, () => 1);
 const p73 = p.then(() => undefined, () => x);
 >p73 : Promise<any>
 >p.then(() => undefined, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => x : () => any
@@ -869,9 +869,9 @@ const p73 = p.then(() => undefined, () => x);
 const p74 = p.then(() => undefined, () => undefined);
 >p74 : Promise<any>
 >p.then(() => undefined, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => undefined : () => any
@@ -880,9 +880,9 @@ const p74 = p.then(() => undefined, () => undefined);
 const p75 = p.then(() => undefined, () => null);
 >p75 : Promise<any>
 >p.then(() => undefined, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => null : () => any
@@ -891,9 +891,9 @@ const p75 = p.then(() => undefined, () => null);
 const p76 = p.then(() => undefined, () => {});
 >p76 : Promise<any>
 >p.then(() => undefined, () => {}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => {} : () => void
@@ -901,9 +901,9 @@ const p76 = p.then(() => undefined, () => {});
 const p77 = p.then(() => undefined, () => {throw 1});
 >p77 : Promise<any>
 >p.then(() => undefined, () => {throw 1}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => {throw 1} : () => never
@@ -912,39 +912,39 @@ const p77 = p.then(() => undefined, () => {throw 1});
 const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >p78 : Promise<any>
 >p.then(() => undefined, () => Promise.resolve(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p79 = p.then(() => undefined, () => Promise.reject(1));
 >p79 : Promise<any>
 >p.then(() => undefined, () => Promise.reject(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p80 = p.then(() => null, undefined);
 >p80 : Promise<any>
 >p.then(() => null, undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >undefined : undefined
@@ -952,9 +952,9 @@ const p80 = p.then(() => null, undefined);
 const p81 = p.then(() => null, null);
 >p81 : Promise<any>
 >p.then(() => null, null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >null : null
@@ -962,9 +962,9 @@ const p81 = p.then(() => null, null);
 const p82 = p.then(() => null, () => 1);
 >p82 : Promise<any>
 >p.then(() => null, () => 1) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => 1 : () => number
@@ -973,9 +973,9 @@ const p82 = p.then(() => null, () => 1);
 const p83 = p.then(() => null, () => x);
 >p83 : Promise<any>
 >p.then(() => null, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => x : () => any
@@ -984,9 +984,9 @@ const p83 = p.then(() => null, () => x);
 const p84 = p.then(() => null, () => undefined);
 >p84 : Promise<any>
 >p.then(() => null, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => undefined : () => any
@@ -995,9 +995,9 @@ const p84 = p.then(() => null, () => undefined);
 const p85 = p.then(() => null, () => null);
 >p85 : Promise<any>
 >p.then(() => null, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => null : () => any
@@ -1006,9 +1006,9 @@ const p85 = p.then(() => null, () => null);
 const p86 = p.then(() => null, () => {});
 >p86 : Promise<any>
 >p.then(() => null, () => {}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => {} : () => void
@@ -1016,9 +1016,9 @@ const p86 = p.then(() => null, () => {});
 const p87 = p.then(() => null, () => {throw 1});
 >p87 : Promise<any>
 >p.then(() => null, () => {throw 1}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => {throw 1} : () => never
@@ -1027,57 +1027,57 @@ const p87 = p.then(() => null, () => {throw 1});
 const p88 = p.then(() => null, () => Promise.resolve(1));
 >p88 : Promise<any>
 >p.then(() => null, () => Promise.resolve(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p89 = p.then(() => null, () => Promise.reject(1));
 >p89 : Promise<any>
 >p.then(() => null, () => Promise.reject(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p90 = p.then(() => {}, undefined);
 >p90 : Promise<void>
 >p.then(() => {}, undefined) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >undefined : undefined
 
 const p91 = p.then(() => {}, null);
 >p91 : Promise<void>
 >p.then(() => {}, null) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >null : null
 
 const p92 = p.then(() => {}, () => 1);
 >p92 : Promise<number | void>
 >p.then(() => {}, () => 1) : Promise<number | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => 1 : () => number
 >1 : 1
@@ -1085,9 +1085,9 @@ const p92 = p.then(() => {}, () => 1);
 const p93 = p.then(() => {}, () => x);
 >p93 : Promise<any>
 >p.then(() => {}, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => x : () => any
 >x : any
@@ -1095,9 +1095,9 @@ const p93 = p.then(() => {}, () => x);
 const p94 = p.then(() => {}, () => undefined);
 >p94 : Promise<any>
 >p.then(() => {}, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => undefined : () => any
 >undefined : undefined
@@ -1105,9 +1105,9 @@ const p94 = p.then(() => {}, () => undefined);
 const p95 = p.then(() => {}, () => null);
 >p95 : Promise<any>
 >p.then(() => {}, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => null : () => any
 >null : null
@@ -1115,18 +1115,18 @@ const p95 = p.then(() => {}, () => null);
 const p96 = p.then(() => {}, () => {});
 >p96 : Promise<void>
 >p.then(() => {}, () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => {} : () => void
 
 const p97 = p.then(() => {}, () => {throw 1});
 >p97 : Promise<void>
 >p.then(() => {}, () => {throw 1}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => {throw 1} : () => never
 >1 : 1
@@ -1134,37 +1134,37 @@ const p97 = p.then(() => {}, () => {throw 1});
 const p98 = p.then(() => {}, () => Promise.resolve(1));
 >p98 : Promise<number | void>
 >p.then(() => {}, () => Promise.resolve(1)) : Promise<number | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p99 = p.then(() => {}, () => Promise.reject(1));
 >p99 : Promise<void>
 >p.then(() => {}, () => Promise.reject(1)) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pa0 = p.then(() => {throw 1}, undefined);
 >pa0 : Promise<never>
 >p.then(() => {throw 1}, undefined) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >undefined : undefined
@@ -1172,9 +1172,9 @@ const pa0 = p.then(() => {throw 1}, undefined);
 const pa1 = p.then(() => {throw 1}, null);
 >pa1 : Promise<never>
 >p.then(() => {throw 1}, null) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >null : null
@@ -1182,9 +1182,9 @@ const pa1 = p.then(() => {throw 1}, null);
 const pa2 = p.then(() => {throw 1}, () => 1);
 >pa2 : Promise<number>
 >p.then(() => {throw 1}, () => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => 1 : () => number
@@ -1193,9 +1193,9 @@ const pa2 = p.then(() => {throw 1}, () => 1);
 const pa3 = p.then(() => {throw 1}, () => x);
 >pa3 : Promise<any>
 >p.then(() => {throw 1}, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => x : () => any
@@ -1204,9 +1204,9 @@ const pa3 = p.then(() => {throw 1}, () => x);
 const pa4 = p.then(() => {throw 1}, () => undefined);
 >pa4 : Promise<any>
 >p.then(() => {throw 1}, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => undefined : () => any
@@ -1215,9 +1215,9 @@ const pa4 = p.then(() => {throw 1}, () => undefined);
 const pa5 = p.then(() => {throw 1}, () => null);
 >pa5 : Promise<any>
 >p.then(() => {throw 1}, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => null : () => any
@@ -1226,9 +1226,9 @@ const pa5 = p.then(() => {throw 1}, () => null);
 const pa6 = p.then(() => {throw 1}, () => {});
 >pa6 : Promise<void>
 >p.then(() => {throw 1}, () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => {} : () => void
@@ -1236,9 +1236,9 @@ const pa6 = p.then(() => {throw 1}, () => {});
 const pa7 = p.then(() => {throw 1}, () => {throw 1});
 >pa7 : Promise<never>
 >p.then(() => {throw 1}, () => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => {throw 1} : () => never
@@ -1247,72 +1247,72 @@ const pa7 = p.then(() => {throw 1}, () => {throw 1});
 const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >pa8 : Promise<number>
 >p.then(() => {throw 1}, () => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
 >pa9 : Promise<never>
 >p.then(() => {throw 1}, () => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >pb0 : Promise<string>
 >p.then(() => Promise.resolve("1"), undefined) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >undefined : undefined
 
 const pb1 = p.then(() => Promise.resolve("1"), null);
 >pb1 : Promise<string>
 >p.then(() => Promise.resolve("1"), null) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >null : null
 
 const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >pb2 : Promise<string | number>
 >p.then(() => Promise.resolve("1"), () => 1) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1320,14 +1320,14 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >pb3 : Promise<any>
 >p.then(() => Promise.resolve("1"), () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1335,14 +1335,14 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x);
 const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >pb4 : Promise<any>
 >p.then(() => Promise.resolve("1"), () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => undefined : () => any
 >undefined : undefined
@@ -1350,14 +1350,14 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >pb5 : Promise<any>
 >p.then(() => Promise.resolve("1"), () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => null : () => any
 >null : null
@@ -1365,28 +1365,28 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null);
 const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >pb6 : Promise<string | void>
 >p.then(() => Promise.resolve("1"), () => {}) : Promise<string | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => {} : () => void
 
 const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >pb7 : Promise<string>
 >p.then(() => Promise.resolve("1"), () => {throw 1}) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1394,80 +1394,80 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >pb8 : Promise<string | number>
 >p.then(() => Promise.resolve("1"), () => Promise.resolve(1)) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >pb9 : Promise<string>
 >p.then(() => Promise.resolve("1"), () => Promise.reject(1)) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pc0 = p.then(() => Promise.reject("1"), undefined);
 >pc0 : Promise<never>
 >p.then(() => Promise.reject("1"), undefined) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >undefined : undefined
 
 const pc1 = p.then(() => Promise.reject("1"), null);
 >pc1 : Promise<never>
 >p.then(() => Promise.reject("1"), null) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >null : null
 
 const pc2 = p.then(() => Promise.reject("1"), () => 1);
 >pc2 : Promise<number>
 >p.then(() => Promise.reject("1"), () => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1475,14 +1475,14 @@ const pc2 = p.then(() => Promise.reject("1"), () => 1);
 const pc3 = p.then(() => Promise.reject("1"), () => x);
 >pc3 : Promise<any>
 >p.then(() => Promise.reject("1"), () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1490,14 +1490,14 @@ const pc3 = p.then(() => Promise.reject("1"), () => x);
 const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 >pc4 : Promise<any>
 >p.then(() => Promise.reject("1"), () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => undefined : () => any
 >undefined : undefined
@@ -1505,14 +1505,14 @@ const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 const pc5 = p.then(() => Promise.reject("1"), () => null);
 >pc5 : Promise<any>
 >p.then(() => Promise.reject("1"), () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => null : () => any
 >null : null
@@ -1520,28 +1520,28 @@ const pc5 = p.then(() => Promise.reject("1"), () => null);
 const pc6 = p.then(() => Promise.reject("1"), () => {});
 >pc6 : Promise<void>
 >p.then(() => Promise.reject("1"), () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => {} : () => void
 
 const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 >pc7 : Promise<never>
 >p.then(() => Promise.reject("1"), () => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1549,38 +1549,38 @@ const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >pc8 : Promise<number>
 >p.then(() => Promise.reject("1"), () => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >pc9 : Promise<never>
 >p.then(() => Promise.reject("1"), () => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
diff --git a/tests/baselines/reference/promiseTypeInference.errors.txt b/tests/baselines/reference/promiseTypeInference.errors.txt
deleted file mode 100644
index fab56c73375f7..0000000000000
--- a/tests/baselines/reference/promiseTypeInference.errors.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-tests/cases/compiler/promiseTypeInference.ts(10,34): error TS2345: Argument of type '(s: string) => IPromise<number>' is not assignable to parameter of type '(value: string) => number | PromiseLike<number>'.
-  Type 'IPromise<number>' is not assignable to type 'number | PromiseLike<number>'.
-    Type 'IPromise<number>' is not assignable to type 'PromiseLike<number>'.
-      Types of property 'then' are incompatible.
-        Type '<U>(success?: (value: number) => IPromise<U>) => IPromise<U>' is not assignable to type '<TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<TResult1 | TResult2>'.
-          Types of parameters 'success' and 'onfulfilled' are incompatible.
-            Type 'TResult1 | PromiseLike<TResult1>' is not assignable to type 'IPromise<TResult1 | TResult2>'.
-              Type 'TResult1' is not assignable to type 'IPromise<TResult1 | TResult2>'.
-
-
-==== tests/cases/compiler/promiseTypeInference.ts (1 errors) ====
-    declare class Promise<T> {
-        then<U>(success?: (value: T) => Promise<U>): Promise<U>;
-    }
-    interface IPromise<T> {
-        then<U>(success?: (value: T) => IPromise<U>): IPromise<U>;
-    }
-    declare function load(name: string): Promise<string>;
-    declare function convert(s: string): IPromise<number>;
-    
-    var $$x = load("something").then(s => convert(s));
-                                     ~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type '(s: string) => IPromise<number>' is not assignable to parameter of type '(value: string) => number | PromiseLike<number>'.
-!!! error TS2345:   Type 'IPromise<number>' is not assignable to type 'number | PromiseLike<number>'.
-!!! error TS2345:     Type 'IPromise<number>' is not assignable to type 'PromiseLike<number>'.
-!!! error TS2345:       Types of property 'then' are incompatible.
-!!! error TS2345:         Type '<U>(success?: (value: number) => IPromise<U>) => IPromise<U>' is not assignable to type '<TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => PromiseLike<TResult1 | TResult2>'.
-!!! error TS2345:           Types of parameters 'success' and 'onfulfilled' are incompatible.
-!!! error TS2345:             Type 'TResult1 | PromiseLike<TResult1>' is not assignable to type 'IPromise<TResult1 | TResult2>'.
-!!! error TS2345:               Type 'TResult1' is not assignable to type 'IPromise<TResult1 | TResult2>'.
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/promiseTypeInference.types b/tests/baselines/reference/promiseTypeInference.types
index f722840ffea66..cbcdc84b78259 100644
--- a/tests/baselines/reference/promiseTypeInference.types
+++ b/tests/baselines/reference/promiseTypeInference.types
@@ -4,7 +4,7 @@ declare class Promise<T> {
 >T : T
 
     then<U>(success?: (value: T) => Promise<U>): Promise<U>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
 >U : U
 >success : (value: T) => Promise<U>
 >value : T
@@ -42,11 +42,11 @@ declare function convert(s: string): IPromise<number>;
 var $$x = load("something").then(s => convert(s));
 >$$x : Promise<number>
 >load("something").then(s => convert(s)) : Promise<number>
->load("something").then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>): Promise<U>; }
+>load("something").then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>): Promise<U>; }
 >load("something") : Promise<string>
 >load : (name: string) => Promise<string>
 >"something" : "something"
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>): Promise<U>; }
 >s => convert(s) : (s: string) => IPromise<number>
 >s : string
 >convert(s) : IPromise<number>
diff --git a/tests/baselines/reference/promiseTypeStrictNull.types b/tests/baselines/reference/promiseTypeStrictNull.types
index 7bb75ec66f234..be751d5dc4a66 100644
--- a/tests/baselines/reference/promiseTypeStrictNull.types
+++ b/tests/baselines/reference/promiseTypeStrictNull.types
@@ -105,9 +105,9 @@ async function F() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -170,9 +170,9 @@ async function I() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -183,231 +183,231 @@ async function I() {
 const p00 = p.catch();
 >p00 : Promise<boolean>
 >p.catch() : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 
 const p01 = p.then();
 >p01 : Promise<boolean>
 >p.then() : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 
 const p10 = p.catch(undefined);
 >p10 : Promise<boolean>
 >p.catch(undefined) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >undefined : undefined
 
 const p11 = p.catch(null);
 >p11 : Promise<boolean>
 >p.catch(null) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >null : null
 
 const p12 = p.catch(() => 1);
 >p12 : Promise<number | boolean>
 >p.catch(() => 1) : Promise<number | boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => 1 : () => number
 >1 : 1
 
 const p13 = p.catch(() => x);
 >p13 : Promise<any>
 >p.catch(() => x) : Promise<any>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => x : () => any
 >x : any
 
 const p14 = p.catch(() => undefined);
 >p14 : Promise<boolean | undefined>
 >p.catch(() => undefined) : Promise<boolean | undefined>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => undefined : () => undefined
 >undefined : undefined
 
 const p15 = p.catch(() => null);
 >p15 : Promise<boolean | null>
 >p.catch(() => null) : Promise<boolean | null>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => null : () => null
 >null : null
 
 const p16 = p.catch(() => {});
 >p16 : Promise<boolean | void>
 >p.catch(() => {}) : Promise<boolean | void>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => {} : () => void
 
 const p17 = p.catch(() => {throw 1});
 >p17 : Promise<boolean>
 >p.catch(() => {throw 1}) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => {throw 1} : () => never
 >1 : 1
 
 const p18 = p.catch(() => Promise.reject(1));
 >p18 : Promise<boolean>
 >p.catch(() => Promise.reject(1)) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p19 = p.catch(() => Promise.resolve(1));
 >p19 : Promise<number | boolean>
 >p.catch(() => Promise.resolve(1)) : Promise<number | boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p20 = p.then(undefined);
 >p20 : Promise<boolean>
 >p.then(undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 
 const p21 = p.then(null);
 >p21 : Promise<boolean>
 >p.then(null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 
 const p22 = p.then(() => 1);
 >p22 : Promise<number>
 >p.then(() => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => 1 : () => number
 >1 : 1
 
 const p23 = p.then(() => x);
 >p23 : Promise<any>
 >p.then(() => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 
 const p24 = p.then(() => undefined);
 >p24 : Promise<undefined>
 >p.then(() => undefined) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 
 const p25 = p.then(() => null);
 >p25 : Promise<null>
 >p.then(() => null) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 
 const p26 = p.then(() => {});
 >p26 : Promise<void>
 >p.then(() => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 
 const p27 = p.then(() => {throw 1});
 >p27 : Promise<never>
 >p.then(() => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 
 const p28 = p.then(() => Promise.resolve(1));
 >p28 : Promise<number>
 >p.then(() => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p29 = p.then(() => Promise.reject(1));
 >p29 : Promise<never>
 >p.then(() => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p30 = p.then(undefined, undefined);
 >p30 : Promise<boolean>
 >p.then(undefined, undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >undefined : undefined
 
 const p31 = p.then(undefined, null);
 >p31 : Promise<boolean>
 >p.then(undefined, null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >null : null
 
 const p32 = p.then(undefined, () => 1);
 >p32 : Promise<number | boolean>
 >p.then(undefined, () => 1) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => 1 : () => number
 >1 : 1
@@ -415,9 +415,9 @@ const p32 = p.then(undefined, () => 1);
 const p33 = p.then(undefined, () => x);
 >p33 : Promise<any>
 >p.then(undefined, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => x : () => any
 >x : any
@@ -425,9 +425,9 @@ const p33 = p.then(undefined, () => x);
 const p34 = p.then(undefined, () => undefined);
 >p34 : Promise<boolean | undefined>
 >p.then(undefined, () => undefined) : Promise<boolean | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => undefined : () => undefined
 >undefined : undefined
@@ -435,9 +435,9 @@ const p34 = p.then(undefined, () => undefined);
 const p35 = p.then(undefined, () => null);
 >p35 : Promise<boolean | null>
 >p.then(undefined, () => null) : Promise<boolean | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => null : () => null
 >null : null
@@ -445,18 +445,18 @@ const p35 = p.then(undefined, () => null);
 const p36 = p.then(undefined, () => {});
 >p36 : Promise<boolean | void>
 >p.then(undefined, () => {}) : Promise<boolean | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => {} : () => void
 
 const p37 = p.then(undefined, () => {throw 1});
 >p37 : Promise<boolean>
 >p.then(undefined, () => {throw 1}) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => {throw 1} : () => never
 >1 : 1
@@ -464,55 +464,55 @@ const p37 = p.then(undefined, () => {throw 1});
 const p38 = p.then(undefined, () => Promise.resolve(1));
 >p38 : Promise<number | boolean>
 >p.then(undefined, () => Promise.resolve(1)) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p39 = p.then(undefined, () => Promise.reject(1));
 >p39 : Promise<boolean>
 >p.then(undefined, () => Promise.reject(1)) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p40 = p.then(null, undefined);
 >p40 : Promise<boolean>
 >p.then(null, undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >undefined : undefined
 
 const p41 = p.then(null, null);
 >p41 : Promise<boolean>
 >p.then(null, null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >null : null
 
 const p42 = p.then(null, () => 1);
 >p42 : Promise<number | boolean>
 >p.then(null, () => 1) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => 1 : () => number
 >1 : 1
@@ -520,9 +520,9 @@ const p42 = p.then(null, () => 1);
 const p43 = p.then(null, () => x);
 >p43 : Promise<any>
 >p.then(null, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => x : () => any
 >x : any
@@ -530,9 +530,9 @@ const p43 = p.then(null, () => x);
 const p44 = p.then(null, () => undefined);
 >p44 : Promise<boolean | undefined>
 >p.then(null, () => undefined) : Promise<boolean | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => undefined : () => undefined
 >undefined : undefined
@@ -540,9 +540,9 @@ const p44 = p.then(null, () => undefined);
 const p45 = p.then(null, () => null);
 >p45 : Promise<boolean | null>
 >p.then(null, () => null) : Promise<boolean | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => null : () => null
 >null : null
@@ -550,18 +550,18 @@ const p45 = p.then(null, () => null);
 const p46 = p.then(null, () => {});
 >p46 : Promise<boolean | void>
 >p.then(null, () => {}) : Promise<boolean | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => {} : () => void
 
 const p47 = p.then(null, () => {throw 1});
 >p47 : Promise<boolean>
 >p.then(null, () => {throw 1}) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => {throw 1} : () => never
 >1 : 1
@@ -569,37 +569,37 @@ const p47 = p.then(null, () => {throw 1});
 const p48 = p.then(null, () => Promise.resolve(1));
 >p48 : Promise<number | boolean>
 >p.then(null, () => Promise.resolve(1)) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p49 = p.then(null, () => Promise.reject(1));
 >p49 : Promise<boolean>
 >p.then(null, () => Promise.reject(1)) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p50 = p.then(() => "1", undefined);
 >p50 : Promise<string>
 >p.then(() => "1", undefined) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >undefined : undefined
@@ -607,9 +607,9 @@ const p50 = p.then(() => "1", undefined);
 const p51 = p.then(() => "1", null);
 >p51 : Promise<string>
 >p.then(() => "1", null) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >null : null
@@ -617,9 +617,9 @@ const p51 = p.then(() => "1", null);
 const p52 = p.then(() => "1", () => 1);
 >p52 : Promise<string | number>
 >p.then(() => "1", () => 1) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => 1 : () => number
@@ -628,9 +628,9 @@ const p52 = p.then(() => "1", () => 1);
 const p53 = p.then(() => "1", () => x);
 >p53 : Promise<any>
 >p.then(() => "1", () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => x : () => any
@@ -639,9 +639,9 @@ const p53 = p.then(() => "1", () => x);
 const p54 = p.then(() => "1", () => undefined);
 >p54 : Promise<string | undefined>
 >p.then(() => "1", () => undefined) : Promise<string | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => undefined : () => undefined
@@ -650,9 +650,9 @@ const p54 = p.then(() => "1", () => undefined);
 const p55 = p.then(() => "1", () => null);
 >p55 : Promise<string | null>
 >p.then(() => "1", () => null) : Promise<string | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => null : () => null
@@ -661,9 +661,9 @@ const p55 = p.then(() => "1", () => null);
 const p56 = p.then(() => "1", () => {});
 >p56 : Promise<string | void>
 >p.then(() => "1", () => {}) : Promise<string | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => {} : () => void
@@ -671,9 +671,9 @@ const p56 = p.then(() => "1", () => {});
 const p57 = p.then(() => "1", () => {throw 1});
 >p57 : Promise<string>
 >p.then(() => "1", () => {throw 1}) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => {throw 1} : () => never
@@ -682,39 +682,39 @@ const p57 = p.then(() => "1", () => {throw 1});
 const p58 = p.then(() => "1", () => Promise.resolve(1));
 >p58 : Promise<string | number>
 >p.then(() => "1", () => Promise.resolve(1)) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p59 = p.then(() => "1", () => Promise.reject(1));
 >p59 : Promise<string>
 >p.then(() => "1", () => Promise.reject(1)) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p60 = p.then(() => x, undefined);
 >p60 : Promise<any>
 >p.then(() => x, undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >undefined : undefined
@@ -722,9 +722,9 @@ const p60 = p.then(() => x, undefined);
 const p61 = p.then(() => x, null);
 >p61 : Promise<any>
 >p.then(() => x, null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >null : null
@@ -732,9 +732,9 @@ const p61 = p.then(() => x, null);
 const p62 = p.then(() => x, () => 1);
 >p62 : Promise<any>
 >p.then(() => x, () => 1) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => 1 : () => number
@@ -743,9 +743,9 @@ const p62 = p.then(() => x, () => 1);
 const p63 = p.then(() => x, () => x);
 >p63 : Promise<any>
 >p.then(() => x, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => x : () => any
@@ -754,9 +754,9 @@ const p63 = p.then(() => x, () => x);
 const p64 = p.then(() => x, () => undefined);
 >p64 : Promise<any>
 >p.then(() => x, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => undefined : () => undefined
@@ -765,9 +765,9 @@ const p64 = p.then(() => x, () => undefined);
 const p65 = p.then(() => x, () => null);
 >p65 : Promise<any>
 >p.then(() => x, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => null : () => null
@@ -776,9 +776,9 @@ const p65 = p.then(() => x, () => null);
 const p66 = p.then(() => x, () => {});
 >p66 : Promise<any>
 >p.then(() => x, () => {}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => {} : () => void
@@ -786,9 +786,9 @@ const p66 = p.then(() => x, () => {});
 const p67 = p.then(() => x, () => {throw 1});
 >p67 : Promise<any>
 >p.then(() => x, () => {throw 1}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => {throw 1} : () => never
@@ -797,39 +797,39 @@ const p67 = p.then(() => x, () => {throw 1});
 const p68 = p.then(() => x, () => Promise.resolve(1));
 >p68 : Promise<any>
 >p.then(() => x, () => Promise.resolve(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p69 = p.then(() => x, () => Promise.reject(1));
 >p69 : Promise<any>
 >p.then(() => x, () => Promise.reject(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p70 = p.then(() => undefined, undefined);
 >p70 : Promise<undefined>
 >p.then(() => undefined, undefined) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >undefined : undefined
@@ -837,9 +837,9 @@ const p70 = p.then(() => undefined, undefined);
 const p71 = p.then(() => undefined, null);
 >p71 : Promise<undefined>
 >p.then(() => undefined, null) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >null : null
@@ -847,9 +847,9 @@ const p71 = p.then(() => undefined, null);
 const p72 = p.then(() => undefined, () => 1);
 >p72 : Promise<number | undefined>
 >p.then(() => undefined, () => 1) : Promise<number | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => 1 : () => number
@@ -858,9 +858,9 @@ const p72 = p.then(() => undefined, () => 1);
 const p73 = p.then(() => undefined, () => x);
 >p73 : Promise<any>
 >p.then(() => undefined, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => x : () => any
@@ -869,9 +869,9 @@ const p73 = p.then(() => undefined, () => x);
 const p74 = p.then(() => undefined, () => undefined);
 >p74 : Promise<undefined>
 >p.then(() => undefined, () => undefined) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => undefined : () => undefined
@@ -880,9 +880,9 @@ const p74 = p.then(() => undefined, () => undefined);
 const p75 = p.then(() => undefined, () => null);
 >p75 : Promise<null | undefined>
 >p.then(() => undefined, () => null) : Promise<null | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => null : () => null
@@ -891,9 +891,9 @@ const p75 = p.then(() => undefined, () => null);
 const p76 = p.then(() => undefined, () => {});
 >p76 : Promise<void | undefined>
 >p.then(() => undefined, () => {}) : Promise<void | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => {} : () => void
@@ -901,9 +901,9 @@ const p76 = p.then(() => undefined, () => {});
 const p77 = p.then(() => undefined, () => {throw 1});
 >p77 : Promise<undefined>
 >p.then(() => undefined, () => {throw 1}) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => {throw 1} : () => never
@@ -912,39 +912,39 @@ const p77 = p.then(() => undefined, () => {throw 1});
 const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >p78 : Promise<number | undefined>
 >p.then(() => undefined, () => Promise.resolve(1)) : Promise<number | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p79 = p.then(() => undefined, () => Promise.reject(1));
 >p79 : Promise<undefined>
 >p.then(() => undefined, () => Promise.reject(1)) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p80 = p.then(() => null, undefined);
 >p80 : Promise<null>
 >p.then(() => null, undefined) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >undefined : undefined
@@ -952,9 +952,9 @@ const p80 = p.then(() => null, undefined);
 const p81 = p.then(() => null, null);
 >p81 : Promise<null>
 >p.then(() => null, null) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >null : null
@@ -962,9 +962,9 @@ const p81 = p.then(() => null, null);
 const p82 = p.then(() => null, () => 1);
 >p82 : Promise<number | null>
 >p.then(() => null, () => 1) : Promise<number | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => 1 : () => number
@@ -973,9 +973,9 @@ const p82 = p.then(() => null, () => 1);
 const p83 = p.then(() => null, () => x);
 >p83 : Promise<any>
 >p.then(() => null, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => x : () => any
@@ -984,9 +984,9 @@ const p83 = p.then(() => null, () => x);
 const p84 = p.then(() => null, () => undefined);
 >p84 : Promise<null | undefined>
 >p.then(() => null, () => undefined) : Promise<null | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => undefined : () => undefined
@@ -995,9 +995,9 @@ const p84 = p.then(() => null, () => undefined);
 const p85 = p.then(() => null, () => null);
 >p85 : Promise<null>
 >p.then(() => null, () => null) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => null : () => null
@@ -1006,9 +1006,9 @@ const p85 = p.then(() => null, () => null);
 const p86 = p.then(() => null, () => {});
 >p86 : Promise<void | null>
 >p.then(() => null, () => {}) : Promise<void | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => {} : () => void
@@ -1016,9 +1016,9 @@ const p86 = p.then(() => null, () => {});
 const p87 = p.then(() => null, () => {throw 1});
 >p87 : Promise<null>
 >p.then(() => null, () => {throw 1}) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => {throw 1} : () => never
@@ -1027,57 +1027,57 @@ const p87 = p.then(() => null, () => {throw 1});
 const p88 = p.then(() => null, () => Promise.resolve(1));
 >p88 : Promise<number | null>
 >p.then(() => null, () => Promise.resolve(1)) : Promise<number | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p89 = p.then(() => null, () => Promise.reject(1));
 >p89 : Promise<null>
 >p.then(() => null, () => Promise.reject(1)) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p90 = p.then(() => {}, undefined);
 >p90 : Promise<void>
 >p.then(() => {}, undefined) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >undefined : undefined
 
 const p91 = p.then(() => {}, null);
 >p91 : Promise<void>
 >p.then(() => {}, null) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >null : null
 
 const p92 = p.then(() => {}, () => 1);
 >p92 : Promise<number | void>
 >p.then(() => {}, () => 1) : Promise<number | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => 1 : () => number
 >1 : 1
@@ -1085,9 +1085,9 @@ const p92 = p.then(() => {}, () => 1);
 const p93 = p.then(() => {}, () => x);
 >p93 : Promise<any>
 >p.then(() => {}, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => x : () => any
 >x : any
@@ -1095,9 +1095,9 @@ const p93 = p.then(() => {}, () => x);
 const p94 = p.then(() => {}, () => undefined);
 >p94 : Promise<void | undefined>
 >p.then(() => {}, () => undefined) : Promise<void | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => undefined : () => undefined
 >undefined : undefined
@@ -1105,9 +1105,9 @@ const p94 = p.then(() => {}, () => undefined);
 const p95 = p.then(() => {}, () => null);
 >p95 : Promise<void | null>
 >p.then(() => {}, () => null) : Promise<void | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => null : () => null
 >null : null
@@ -1115,18 +1115,18 @@ const p95 = p.then(() => {}, () => null);
 const p96 = p.then(() => {}, () => {});
 >p96 : Promise<void>
 >p.then(() => {}, () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => {} : () => void
 
 const p97 = p.then(() => {}, () => {throw 1});
 >p97 : Promise<void>
 >p.then(() => {}, () => {throw 1}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => {throw 1} : () => never
 >1 : 1
@@ -1134,37 +1134,37 @@ const p97 = p.then(() => {}, () => {throw 1});
 const p98 = p.then(() => {}, () => Promise.resolve(1));
 >p98 : Promise<number | void>
 >p.then(() => {}, () => Promise.resolve(1)) : Promise<number | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p99 = p.then(() => {}, () => Promise.reject(1));
 >p99 : Promise<void>
 >p.then(() => {}, () => Promise.reject(1)) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pa0 = p.then(() => {throw 1}, undefined);
 >pa0 : Promise<never>
 >p.then(() => {throw 1}, undefined) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >undefined : undefined
@@ -1172,9 +1172,9 @@ const pa0 = p.then(() => {throw 1}, undefined);
 const pa1 = p.then(() => {throw 1}, null);
 >pa1 : Promise<never>
 >p.then(() => {throw 1}, null) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >null : null
@@ -1182,9 +1182,9 @@ const pa1 = p.then(() => {throw 1}, null);
 const pa2 = p.then(() => {throw 1}, () => 1);
 >pa2 : Promise<number>
 >p.then(() => {throw 1}, () => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => 1 : () => number
@@ -1193,9 +1193,9 @@ const pa2 = p.then(() => {throw 1}, () => 1);
 const pa3 = p.then(() => {throw 1}, () => x);
 >pa3 : Promise<any>
 >p.then(() => {throw 1}, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => x : () => any
@@ -1204,9 +1204,9 @@ const pa3 = p.then(() => {throw 1}, () => x);
 const pa4 = p.then(() => {throw 1}, () => undefined);
 >pa4 : Promise<undefined>
 >p.then(() => {throw 1}, () => undefined) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => undefined : () => undefined
@@ -1215,9 +1215,9 @@ const pa4 = p.then(() => {throw 1}, () => undefined);
 const pa5 = p.then(() => {throw 1}, () => null);
 >pa5 : Promise<null>
 >p.then(() => {throw 1}, () => null) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => null : () => null
@@ -1226,9 +1226,9 @@ const pa5 = p.then(() => {throw 1}, () => null);
 const pa6 = p.then(() => {throw 1}, () => {});
 >pa6 : Promise<void>
 >p.then(() => {throw 1}, () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => {} : () => void
@@ -1236,9 +1236,9 @@ const pa6 = p.then(() => {throw 1}, () => {});
 const pa7 = p.then(() => {throw 1}, () => {throw 1});
 >pa7 : Promise<never>
 >p.then(() => {throw 1}, () => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => {throw 1} : () => never
@@ -1247,72 +1247,72 @@ const pa7 = p.then(() => {throw 1}, () => {throw 1});
 const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >pa8 : Promise<number>
 >p.then(() => {throw 1}, () => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
 >pa9 : Promise<never>
 >p.then(() => {throw 1}, () => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >pb0 : Promise<string>
 >p.then(() => Promise.resolve("1"), undefined) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >undefined : undefined
 
 const pb1 = p.then(() => Promise.resolve("1"), null);
 >pb1 : Promise<string>
 >p.then(() => Promise.resolve("1"), null) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >null : null
 
 const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >pb2 : Promise<string | number>
 >p.then(() => Promise.resolve("1"), () => 1) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1320,14 +1320,14 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >pb3 : Promise<any>
 >p.then(() => Promise.resolve("1"), () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1335,14 +1335,14 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x);
 const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >pb4 : Promise<string | undefined>
 >p.then(() => Promise.resolve("1"), () => undefined) : Promise<string | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => undefined : () => undefined
 >undefined : undefined
@@ -1350,14 +1350,14 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >pb5 : Promise<string | null>
 >p.then(() => Promise.resolve("1"), () => null) : Promise<string | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => null : () => null
 >null : null
@@ -1365,28 +1365,28 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null);
 const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >pb6 : Promise<string | void>
 >p.then(() => Promise.resolve("1"), () => {}) : Promise<string | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => {} : () => void
 
 const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >pb7 : Promise<string>
 >p.then(() => Promise.resolve("1"), () => {throw 1}) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1394,80 +1394,80 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >pb8 : Promise<string | number>
 >p.then(() => Promise.resolve("1"), () => Promise.resolve(1)) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >pb9 : Promise<string>
 >p.then(() => Promise.resolve("1"), () => Promise.reject(1)) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pc0 = p.then(() => Promise.reject("1"), undefined);
 >pc0 : Promise<never>
 >p.then(() => Promise.reject("1"), undefined) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >undefined : undefined
 
 const pc1 = p.then(() => Promise.reject("1"), null);
 >pc1 : Promise<never>
 >p.then(() => Promise.reject("1"), null) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >null : null
 
 const pc2 = p.then(() => Promise.reject("1"), () => 1);
 >pc2 : Promise<number>
 >p.then(() => Promise.reject("1"), () => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1475,14 +1475,14 @@ const pc2 = p.then(() => Promise.reject("1"), () => 1);
 const pc3 = p.then(() => Promise.reject("1"), () => x);
 >pc3 : Promise<any>
 >p.then(() => Promise.reject("1"), () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1490,14 +1490,14 @@ const pc3 = p.then(() => Promise.reject("1"), () => x);
 const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 >pc4 : Promise<undefined>
 >p.then(() => Promise.reject("1"), () => undefined) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => undefined : () => undefined
 >undefined : undefined
@@ -1505,14 +1505,14 @@ const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 const pc5 = p.then(() => Promise.reject("1"), () => null);
 >pc5 : Promise<null>
 >p.then(() => Promise.reject("1"), () => null) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => null : () => null
 >null : null
@@ -1520,28 +1520,28 @@ const pc5 = p.then(() => Promise.reject("1"), () => null);
 const pc6 = p.then(() => Promise.reject("1"), () => {});
 >pc6 : Promise<void>
 >p.then(() => Promise.reject("1"), () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => {} : () => void
 
 const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 >pc7 : Promise<never>
 >p.then(() => Promise.reject("1"), () => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1549,38 +1549,38 @@ const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >pc8 : Promise<number>
 >p.then(() => Promise.reject("1"), () => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >pc9 : Promise<never>
 >p.then(() => Promise.reject("1"), () => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.types b/tests/baselines/reference/promiseVoidErrorCallback.types
index bd1b3a87c2603..01448dd8e110f 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.types
+++ b/tests/baselines/reference/promiseVoidErrorCallback.types
@@ -27,9 +27,9 @@ function f1(): Promise<T1> {
 
     return Promise.resolve({ __t1: "foo_t1" });
 >Promise.resolve({ __t1: "foo_t1" }) : Promise<{ __t1: string; }>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >{ __t1: "foo_t1" } : { __t1: string; }
 >__t1 : string
 >"foo_t1" : "foo_t1"
@@ -54,14 +54,14 @@ function f2(x: T1): T2 {
 var x3 = f1()
 >x3 : Promise<{ __t3: string; }>
 >f1()    .then(f2, (e: Error) => {    throw e;})    .then((x: T2) => {    return { __t3: x.__t2 + "bar" };}) : Promise<{ __t3: string; }>
->f1()    .then(f2, (e: Error) => {    throw e;})    .then : <TResult1 = T2, TResult2 = never>(onfulfilled?: (value: T2) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>f1()    .then(f2, (e: Error) => {    throw e;})    .then : <TResult1 = T2, TResult2 = never>(onfulfilled?: (value: T2) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f1()    .then(f2, (e: Error) => {    throw e;}) : Promise<T2>
->f1()    .then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>f1()    .then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f1() : Promise<T1>
 >f1 : () => Promise<T1>
 
     .then(f2, (e: Error) => {
->then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f2 : (x: T1) => T2
 >(e: Error) => {    throw e;} : (e: Error) => never
 >e : Error
@@ -72,7 +72,7 @@ var x3 = f1()
 
 })
     .then((x: T2) => {
->then : <TResult1 = T2, TResult2 = never>(onfulfilled?: (value: T2) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = T2, TResult2 = never>(onfulfilled?: (value: T2) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >(x: T2) => {    return { __t3: x.__t2 + "bar" };} : (x: T2) => { __t3: string; }
 >x : T2
 >T2 : T2
diff --git a/tests/baselines/reference/promises.types b/tests/baselines/reference/promises.types
index 7d255a05ffb82..b2d200444b547 100644
--- a/tests/baselines/reference/promises.types
+++ b/tests/baselines/reference/promises.types
@@ -4,7 +4,7 @@ interface Promise<T> {
 >T : T
 
     then<U>(success?: (value: T) => U): Promise<U>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
 >U : U
 >success : (value: T) => U
 >value : T
@@ -14,7 +14,7 @@ interface Promise<T> {
 >U : U
 
     then<U>(success?: (value: T) => Promise<U>): Promise<U>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
 >U : U
 >success : (value: T) => Promise<U>
 >value : T
diff --git a/tests/baselines/reference/specializationError.types b/tests/baselines/reference/specializationError.types
index 07cbc3d76d0ef..30b217bcd8de2 100644
--- a/tests/baselines/reference/specializationError.types
+++ b/tests/baselines/reference/specializationError.types
@@ -4,7 +4,7 @@ interface Promise<T> {
 >T : T
 
     then<U>(value: T): void;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(value: T): void; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(value: T): void; }
 >U : U
 >value : T
 >T : T
diff --git a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types
index 1c38ecc466ce5..fbd0f6ff995ad 100644
--- a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types
+++ b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types
@@ -9,10 +9,10 @@ export = packageExport;
 === tests/cases/compiler/index.ts ===
 import("package").then(({default: foo}) => foo(42));
 >import("package").then(({default: foo}) => foo(42)) : Promise<string>
->import("package").then : <TResult1 = ((x: number) => string) & { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: ((x: number) => string) & { default: (x: number) => string; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>import("package").then : <TResult1 = ((x: number) => string) & { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: ((x: number) => string) & { default: (x: number) => string; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >import("package") : Promise<((x: number) => string) & { default: (x: number) => string; }>
 >"package" : "package"
->then : <TResult1 = ((x: number) => string) & { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: ((x: number) => string) & { default: (x: number) => string; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = ((x: number) => string) & { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: ((x: number) => string) & { default: (x: number) => string; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >({default: foo}) => foo(42) : ({ default: foo }: ((x: number) => string) & { default: (x: number) => string; }) => string
 >default : any
 >foo : (x: number) => string
diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.types b/tests/baselines/reference/transformNestedGeneratorsWithTry.types
index 3e4ef3f0852cf..3fcacaacafbd7 100644
--- a/tests/baselines/reference/transformNestedGeneratorsWithTry.types
+++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.types
@@ -18,9 +18,9 @@ async function a(): Bluebird<void> {
         await Bluebird.resolve(); // -- remove this and it compiles
 >await Bluebird.resolve() : void
 >Bluebird.resolve() : Promise<void>
->Bluebird.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Bluebird.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Bluebird : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 
       } catch (error) { }
 >error : any
diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.1.types b/tests/baselines/reference/types.asyncGenerators.esnext.1.types
index 1a72da228e762..c7d5e2d033345 100644
--- a/tests/baselines/reference/types.asyncGenerators.esnext.1.types
+++ b/tests/baselines/reference/types.asyncGenerators.esnext.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 : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >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 : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >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 : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * inferReturnType8() {
@@ -91,9 +91,9 @@ const assignability2: () => AsyncIterableIterator<number> = async function * ()
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -118,9 +118,9 @@ const assignability4: () => AsyncIterableIterator<number> = async function * ()
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -156,9 +156,9 @@ const assignability7: () => AsyncIterable<number> = async function * () {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -183,9 +183,9 @@ const assignability9: () => AsyncIterable<number> = async function * () {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -221,9 +221,9 @@ const assignability12: () => AsyncIterator<number> = async function * () {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -248,9 +248,9 @@ const assignability14: () => AsyncIterator<number> = async function * () {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -283,9 +283,9 @@ async function * explicitReturnType2(): AsyncIterableIterator<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType3(): AsyncIterableIterator<number> {
@@ -306,9 +306,9 @@ async function * explicitReturnType4(): AsyncIterableIterator<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType5(): AsyncIterableIterator<number> {
@@ -338,9 +338,9 @@ async function * explicitReturnType7(): AsyncIterable<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType8(): AsyncIterable<number> {
@@ -361,9 +361,9 @@ async function * explicitReturnType9(): AsyncIterable<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType10(): AsyncIterable<number> {
@@ -393,9 +393,9 @@ async function * explicitReturnType12(): AsyncIterator<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType13(): AsyncIterator<number> {
@@ -416,9 +416,9 @@ async function * explicitReturnType14(): AsyncIterator<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType15(): AsyncIterator<number> {
@@ -455,8 +455,8 @@ async function * awaitedType2() {
 >x : number
 >await Promise.resolve(1) : number
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
diff --git a/tests/cases/conformance/types/awaited/awaited.ts b/tests/cases/conformance/types/awaited/awaited.ts
new file mode 100644
index 0000000000000..91564b4945c24
--- /dev/null
+++ b/tests/cases/conformance/types/awaited/awaited.ts
@@ -0,0 +1,96 @@
+// @target: es2015
+// @declaration: true
+// simple
+declare const p0: Promise<number>;
+p0.then(x => x);
+
+declare const p1: Promise<Promise<number>>;
+p1.then(x => x);
+
+declare const p2: Promise<number | Promise<number>>;
+p2.then(x => x);
+
+// generics
+declare const f: boolean;
+declare function makePromise<T>(x: T): Promise<T>;
+makePromise(1).then(x => x);
+makePromise("a").then(x => x);
+makePromise({ a: 1 }).then(x => x);
+makePromise(f ? 1 : "a").then(x => x);
+
+function f0<U>(u: U) {
+    return makePromise(u).then(x => x);
+}
+f0(1).then(x => x);
+f0("a").then(x => x);
+f0(f ? 1 : "a").then(x => x);
+f0(makePromise(1)).then(x => x);
+
+function f1<U, V>(u: U, v: V) {
+    return makePromise(u).then(x => {
+        if (f) return x;
+        return makePromise(v).then(x => x);
+    });
+}
+f1(1, "a").then(x => x);
+f1(makePromise(1), makePromise("a")).then(x => x);
+
+function f2<U>(u: U) {
+    return makePromise(u).then(x => {
+        if (f) return x;
+        return Promise.reject("b");
+    });
+}
+f2(1).then(x => x);
+f2(makePromise(1)).then(x => x);
+
+function f3<U, V>(u: U, v: V) {
+    return makePromise(u).catch(x => v);
+}
+f3(1, "a").then(x => x);
+f3(makePromise(1), makePromise("a")).then(x => x);
+
+function f4<U, V>(u: U, v: V) {
+    return makePromise(u).catch(x => {
+        if (f) return v;
+        return Promise.reject("b");
+    });
+}
+f4(1, "a").then(x => x);
+f4(makePromise(1), makePromise("a")).then(x => x);
+
+async function f5<U>(u: Promise<U>) {
+    return await u;
+}
+f5(makePromise(1)).then(x => x);
+f5(makePromise(makePromise(1))).then(x => x);
+
+async function f6<U>(u: Promise<Promise<U>>) {
+    return await u;
+}
+
+// assignability
+let v0: number;
+let v1: awaited number;
+let v2: awaited Promise<number>;
+v0 = v1;
+v0 = v2;
+v1 = v0;
+v1 = v2;
+v2 = v0;
+v2 = v1;
+
+function f7<U>() {
+    let v0: awaited U;
+    let v1: awaited Promise<U>;
+    v0 = v1;
+    v1 = v0;
+}
+
+async function f8<U>() {
+    let pu: Promise<U>;
+    let v0: awaited U;
+    let v1: awaited Promise<U>;
+    v0 = await pu;
+    v1 = await pu;
+}
\ No newline at end of file
diff --git a/tests/cases/fourslash/completionInJSDocFunctionNew.ts b/tests/cases/fourslash/completionInJSDocFunctionNew.ts
index 0d3391cf7745b..6a06ec76fe5b9 100644
--- a/tests/cases/fourslash/completionInJSDocFunctionNew.ts
+++ b/tests/cases/fourslash/completionInJSDocFunctionNew.ts
@@ -6,5 +6,5 @@
 ////var f = function () { return new/**/; }
 
 goTo.marker();
-verify.completionListCount(115);
+verify.completionListCount(116);
 verify.completionListContains('new');
diff --git a/tests/cases/fourslash/completionInJSDocFunctionThis.ts b/tests/cases/fourslash/completionInJSDocFunctionThis.ts
index c28eeeb397f1c..b161b4eff68fc 100644
--- a/tests/cases/fourslash/completionInJSDocFunctionThis.ts
+++ b/tests/cases/fourslash/completionInJSDocFunctionThis.ts
@@ -5,6 +5,6 @@
 ////var f = function (s) { return this/**/; }
 
 goTo.marker();
-verify.completionListCount(116);
+verify.completionListCount(117);
 verify.completionListContains('this');