diff --git a/.eslintignore b/.eslintignore
index 404b4177c97..77f2594d4e8 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -1,4 +1,9 @@
 /built/local/**
 /tests/**
 /lib/**
-/src/lib/*.generated.d.ts
\ No newline at end of file
+/src/lib/*.generated.d.ts
+
+# TODO: Remove the following once typescript-eslint supports `awaited`:
+/src/lib/es5.d.ts
+/src/lib/es2015.iterable.d.ts
+/src/lib/es2015.promise.d.ts
\ No newline at end of file
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 08351cf9f58..8c64621ba6b 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -3938,6 +3938,11 @@ namespace ts {
                     context.approximateLength += 2;
                     return createIndexedAccessTypeNode(objectTypeNode, indexTypeNode);
                 }
+                if (type.flags & TypeFlags.Awaited) {
+                    const awaitedTypeNode = typeToTypeNodeHelper((<AwaitedType>type).typeVariable, context);
+                    context.approximateLength += 9;
+                    return createTypeOperatorNode(SyntaxKind.AwaitedKeyword, awaitedTypeNode);
+                }
                 if (type.flags & TypeFlags.Conditional) {
                     const checkTypeNode = typeToTypeNodeHelper((<ConditionalType>type).checkType, context);
                     const saveInferTypeParameters = context.inferTypeParameters;
@@ -9739,6 +9744,10 @@ namespace ts {
                     constraintDepth--;
                     return result;
                 }
+                if (t.flags & TypeFlags.Awaited) {
+                    const basePromiseType = getBaseConstraint((<AwaitedType>t).typeVariable);
+                    return basePromiseType ? getAwaitedType(basePromiseType) : undefined;
+                }
                 if (t.flags & TypeFlags.Substitution) {
                     return getBaseConstraint((<SubstitutionType>t).substitute);
                 }
@@ -11967,6 +11976,9 @@ namespace ts {
                     case SyntaxKind.ReadonlyKeyword:
                         links.resolvedType = getTypeFromTypeNode(node.type);
                         break;
+                    case SyntaxKind.AwaitedKeyword:
+                        links.resolvedType = getAwaitedType(getTypeFromTypeNode(node.type)) ?? unknownType;
+                        break;
                     default:
                         throw Debug.assertNever(node.operator);
                 }
@@ -13452,6 +13464,9 @@ namespace ts {
             if (flags & TypeFlags.Conditional) {
                 return getConditionalTypeInstantiation(<ConditionalType>type, combineTypeMappers((<ConditionalType>type).mapper, mapper));
             }
+            if (flags & TypeFlags.Awaited) {
+                return getAwaitedType(instantiateType((<AwaitedType>type).typeVariable, mapper)) ?? unknownType;
+            }
             if (flags & TypeFlags.Substitution) {
                 const maybeVariable = instantiateType((<SubstitutionType>type).typeVariable, mapper);
                 if (maybeVariable.flags & TypeFlags.TypeVariable) {
@@ -15342,6 +15357,15 @@ namespace ts {
                         }
                     }
                 }
+                else if (target.flags & TypeFlags.Awaited && source.flags & TypeFlags.Awaited) {
+                    // An `awaited S` is related to an `awaited T` if `S` is related to `T`:
+                    //
+                    //  S <: T ⇒ awaited S <: awaited T
+                    //
+                    if (result = isRelatedTo((<AwaitedType>source).typeVariable, (<AwaitedType>target).typeVariable, reportErrors)) {
+                        return result;
+                    }
+                }
                 else if (isGenericMappedType(target)) {
                     // A source type T is related to a target type { [P in X]: T[P] }
                     const template = getTemplateTypeFromMappedType(target);
@@ -15456,6 +15480,21 @@ namespace ts {
                         }
                     }
                 }
+                else if (source.flags & TypeFlags.Awaited) {
+                    // An `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
+                    //
+                    // For example `awaited Promise<number>` is assignable to `number`.
+                    const constraint = getConstraintOfType((<AwaitedType>source).typeVariable);
+                    const awaitedConstraint = constraint && getAwaitedType(constraint);
+                    if (awaitedConstraint) {
+                        if (result = isRelatedTo(awaitedConstraint, target, reportErrors)) {
+                            return result;
+                        }
+                    }
+                }
                 else {
                     // An empty object type is related to any mapped type that includes a '?' modifier.
                     if (relation !== subtypeRelation && relation !== strictSubtypeRelation && isPartialMappedType(target) && isEmptyObjectType(source)) {
@@ -17686,6 +17725,9 @@ namespace ts {
                     inferFromTypes(getTrueTypeFromConditionalType(<ConditionalType>source), getTrueTypeFromConditionalType(<ConditionalType>target));
                     inferFromTypes(getFalseTypeFromConditionalType(<ConditionalType>source), getFalseTypeFromConditionalType(<ConditionalType>target));
                 }
+                else if (source.flags & TypeFlags.Awaited && target.flags && TypeFlags.Awaited) {
+                    inferFromTypes((<AwaitedType>source).typeVariable, (<AwaitedType>target).typeVariable);
+                }
                 else if (target.flags & TypeFlags.Conditional) {
                     const savePriority = priority;
                     priority |= contravariant ? InferencePriority.ContravariantConditional : 0;
@@ -17693,6 +17735,10 @@ namespace ts {
                     inferToMultipleTypes(source, targetTypes, target.flags);
                     priority = savePriority;
                 }
+                else if (target.flags & TypeFlags.Awaited) {
+                    const targetTypes = [(<AwaitedType>target).typeVariable, createPromiseLikeType((<AwaitedType>target).typeVariable)];
+                    inferToMultipleTypes(source, targetTypes, target.flags);
+                }
                 else if (target.flags & TypeFlags.UnionOrIntersection) {
                     inferToMultipleTypes(source, (<UnionOrIntersectionType>target).types, target.flags);
                 }
@@ -21138,7 +21184,10 @@ namespace ts {
                 const contextualReturnType = getContextualReturnType(func);
                 if (contextualReturnType) {
                     if (functionFlags & FunctionFlags.Async) { // Async function
-                        const contextualAwaitedType = getAwaitedTypeOfPromise(contextualReturnType);
+                        let contextualAwaitedType = getAwaitedTypeOfPromise(contextualReturnType);
+                        if (contextualAwaitedType && contextualAwaitedType.flags & TypeFlags.Awaited) {
+                            contextualAwaitedType = (<AwaitedType>contextualAwaitedType).typeVariable;
+                        }
                         return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
                     }
                     return contextualReturnType; // Regular function
@@ -21150,7 +21199,10 @@ namespace ts {
         function getContextualTypeForAwaitOperand(node: AwaitExpression): Type | undefined {
             const contextualType = getContextualType(node);
             if (contextualType) {
-                const contextualAwaitedType = getAwaitedType(contextualType);
+                let contextualAwaitedType = getAwaitedType(contextualType);
+                if (contextualAwaitedType && contextualAwaitedType.flags & TypeFlags.Awaited) {
+                    contextualAwaitedType = (<AwaitedType>contextualAwaitedType).typeVariable;
+                }
                 return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
             }
             return undefined;
@@ -29207,9 +29259,9 @@ namespace ts {
          * @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.
          */
-        function getPromisedTypeOfPromise(promise: Type, errorNode?: Node): Type | undefined {
+        function getPromisedTypeOfPromise(type: Type, errorNode?: Node): Type | undefined {
             //
-            //  { // promise
+            //  { // type
             //      then( // thenFunction
             //          onfulfilled: ( // onfulfilledParameterType
             //              value: T // valueParameterType
@@ -29218,20 +29270,21 @@ namespace ts {
             //  }
             //
 
-            if (isTypeAny(promise)) {
+            if (isTypeAny(type)) {
                 return undefined;
             }
 
-            const typeAsPromise = <PromiseOrAwaitableType>promise;
+            const typeAsPromise = <PromiseOrAwaitableType>type;
             if (typeAsPromise.promisedTypeOfPromise) {
                 return typeAsPromise.promisedTypeOfPromise;
             }
 
-            if (isReferenceToType(promise, getGlobalPromiseType(/*reportErrors*/ false))) {
-                return typeAsPromise.promisedTypeOfPromise = getTypeArguments(<GenericType>promise)[0];
+            if (isReferenceToType(type, getGlobalPromiseType(/*reportErrors*/ false)) ||
+                isReferenceToType(type, getGlobalPromiseLikeType(/*reportErrors*/ false))) {
+                return typeAsPromise.promisedTypeOfPromise = getTypeArguments(<GenericType>type)[0];
             }
 
-            const thenFunction = getTypeOfPropertyOfType(promise, "then" as __String)!; // TODO: GH#18217
+            const thenFunction = getTypeOfPropertyOfType(type, "then" as __String)!; // TODO: GH#18217
             if (isTypeAny(thenFunction)) {
                 return undefined;
             }
@@ -29272,6 +29325,32 @@ namespace ts {
             return awaitedType || errorType;
         }
 
+        /**
+         * Gets or creates an `awaited T` type for a type variable.
+         *
+         * The "awaited type" of a type variable cannot be determined until it is instantiated. As
+         * a result, an `AwaitedType` for the type variable is created that can be instantiated
+         * or related later.
+         */
+        function getAwaitedTypeForGenericType(type: TypeVariable) {
+            if (!type.resolvedAwaitedType) {
+                type.resolvedAwaitedType = <AwaitedType>createType(TypeFlags.Awaited);
+                type.resolvedAwaitedType.typeVariable = type;
+            }
+            return type.resolvedAwaitedType;
+        }
+
+        /**
+         * Gets the "awaited type" of a type.
+         *
+         * 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. If the "promised
+         * type" is itself a Promise-like, the "promised 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, arg0?: string | number): Type | undefined {
             const typeAsAwaitable = <PromiseOrAwaitableType>type;
             if (typeAsAwaitable.awaitedTypeOfType) {
@@ -29279,25 +29358,56 @@ namespace ts {
             }
 
             if (isTypeAny(type)) {
-                return typeAsAwaitable.awaitedTypeOfType = type;
+                return type;
             }
 
-            if (type.flags & TypeFlags.Union) {
-                let types: Type[] | undefined;
-                for (const constituentType of (<UnionType>type).types) {
-                    types = append<Type>(types, getAwaitedType(constituentType, errorNode, diagnosticMessage, arg0));
-                }
+            // For a union, get a union of the awaited types of each constituent.
+            //
+            // For example:
+            //
+            //   awaited (number | string)          -> number | string
+            //   awaited (number | Promise<string>) -> number | string
+            //   awaited (T | string)               -> awaited T | string
+            //   awaited (T | Promise<string>)      -> awaited T | string
+            //   awaited (T | Promise<never>)       -> awaited T
+            //   awaited (T | U)                    -> awaited T | awaited U
+            //
+            return typeAsAwaitable.awaitedTypeOfType =
+                mapType(type, errorNode ? constituentType => getAwaitedTypeWorker(constituentType, errorNode, diagnosticMessage, arg0) : getAwaitedTypeWorker);
+        }
 
-                if (!types) {
-                    return undefined;
-                }
+        function getAwaitedTypeWorker(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage, arg0?: string | number): Type | undefined {
+            // If the type is already an awaited type, return it.
+            //
+            // For example:
+            //
+            //   awaited T -> awaited T
+            //
+            if (type.flags & TypeFlags.Awaited) {
+                return type;
+            }
 
-                return typeAsAwaitable.awaitedTypeOfType = getUnionType(types);
+            // We cannot resolve the awaited type for a type variable until it is instantiated. As
+            // such, we create an `awaited T` type that can either be instantiated or related later.
+            //
+            // For example:
+            //
+            //   T -> awaited T
+            //
+            if (maybeTypeOfKind(type, TypeFlags.Instantiable | TypeFlags.GenericMappedType)) {
+                return getAwaitedTypeForGenericType(<TypeVariable>type);
+            }
+
+            const typeAsAwaitable = <PromiseOrAwaitableType>type;
+
+            // Use the cached type if already computed.
+            if (typeAsAwaitable.awaitedTypeOfType) {
+                return typeAsAwaitable.awaitedTypeOfType;
             }
 
             const promisedType = getPromisedTypeOfPromise(type);
             if (promisedType) {
-                if (type.id === promisedType.id || awaitedTypeStack.indexOf(promisedType.id) >= 0) {
+                if (type.id === promisedType.id || awaitedTypeStack.lastIndexOf(promisedType.id) >= 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
diff --git a/src/compiler/factoryPublic.ts b/src/compiler/factoryPublic.ts
index 0d9adc26d9c..31f70da50a4 100644
--- a/src/compiler/factoryPublic.ts
+++ b/src/compiler/factoryPublic.ts
@@ -936,8 +936,8 @@ namespace ts {
     }
 
     export function createTypeOperatorNode(type: TypeNode): TypeOperatorNode;
-    export function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
-    export function createTypeOperatorNode(operatorOrType: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | TypeNode, type?: TypeNode) {
+    export function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword, type: TypeNode): TypeOperatorNode;
+    export function createTypeOperatorNode(operatorOrType: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword | TypeNode, type?: TypeNode) {
         const node = createSynthesizedNode(SyntaxKind.TypeOperator) as TypeOperatorNode;
         node.operator = typeof operatorOrType === "number" ? operatorOrType : SyntaxKind.KeyOfKeyword;
         node.type = parenthesizeElementTypeMember(typeof operatorOrType === "number" ? type! : operatorOrType);
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 2287c414316..ba4a5cfc1fa 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -3205,7 +3205,7 @@ namespace ts {
             return finishNode(postfix);
         }
 
-        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {
+        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword) {
             const node = <TypeOperatorNode>createNode(SyntaxKind.TypeOperator);
             parseExpected(operator);
             node.operator = operator;
@@ -3228,6 +3228,7 @@ namespace ts {
                 case SyntaxKind.KeyOfKeyword:
                 case SyntaxKind.UniqueKeyword:
                 case SyntaxKind.ReadonlyKeyword:
+                case SyntaxKind.AwaitedKeyword:
                     return parseTypeOperator(operator);
                 case SyntaxKind.InferKeyword:
                     return parseInferType();
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index 2ccc8ef270d..e7af982aced 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -140,6 +140,7 @@ namespace ts {
         yield: SyntaxKind.YieldKeyword,
         async: SyntaxKind.AsyncKeyword,
         await: SyntaxKind.AwaitKeyword,
+        awaited: SyntaxKind.AwaitedKeyword,
         of: SyntaxKind.OfKeyword,
     };
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 107f2b81552..380e4e5f4e5 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -104,6 +104,7 @@ namespace ts {
         | SyntaxKind.YieldKeyword
         | SyntaxKind.AsyncKeyword
         | SyntaxKind.AwaitKeyword
+        | SyntaxKind.AwaitedKeyword
         | SyntaxKind.OfKeyword;
 
     export type JsxTokenSyntaxKind =
@@ -258,6 +259,7 @@ namespace ts {
         AnyKeyword,
         AsyncKeyword,
         AwaitKeyword,
+        AwaitedKeyword,
         BooleanKeyword,
         ConstructorKeyword,
         DeclareKeyword,
@@ -1314,7 +1316,7 @@ namespace ts {
 
     export interface TypeOperatorNode extends TypeNode {
         kind: SyntaxKind.TypeOperator;
-        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
+        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword;
         type: TypeNode;
     }
 
@@ -4265,6 +4267,7 @@ namespace ts {
         Conditional     = 1 << 24,  // T extends U ? X : Y
         Substitution    = 1 << 25,  // Type parameter substitution
         NonPrimitive    = 1 << 26,  // intrinsic object type
+        Awaited         = 1 << 27,  // awaited T
 
         /* @internal */
         AnyOrUnknown = Any | Unknown,
@@ -4294,7 +4297,7 @@ namespace ts {
         UnionOrIntersection = Union | Intersection,
         StructuredType = Object | Union | Intersection,
         TypeVariable = TypeParameter | IndexedAccess,
-        InstantiableNonPrimitive = TypeVariable | Conditional | Substitution,
+        InstantiableNonPrimitive = TypeVariable | Conditional | Substitution | Awaited,
         InstantiablePrimitive = Index,
         Instantiable = InstantiableNonPrimitive | InstantiablePrimitive,
         StructuredOrInstantiable = StructuredType | Instantiable,
@@ -4546,6 +4549,8 @@ namespace ts {
         resolvedBaseConstraint: Type;
         /* @internal */
         couldContainTypeVariables: boolean;
+        /* @internal */
+        resolvedAwaitedType?: AwaitedType;
     }
 
     export interface UnionType extends UnionOrIntersectionType {
@@ -4642,6 +4647,8 @@ namespace ts {
         resolvedIndexType?: IndexType;
         /* @internal */
         resolvedStringIndexType?: IndexType;
+        /* @internal */
+        resolvedAwaitedType?: AwaitedType;
     }
 
     // Type parameters (TypeFlags.TypeParameter)
@@ -4722,6 +4729,11 @@ namespace ts {
         substitute: Type;            // Type to substitute for type parameter
     }
 
+    // awaited T (TypeFlags.Awaited)
+    export interface AwaitedType extends InstantiableType {
+        typeVariable: TypeVariable;
+    }
+
     /* @internal */
     export const enum JsxReferenceKind {
         Component,
diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index 937f99d3409..d590448db38 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -203,7 +203,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
@@ -211,7 +211,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 45b0fa5dc59..d1d37c3ea26 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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike <T4>]): Promise<[T1, T2, T3, T4]>;
+    all<T1, T2, T3, T4>(values: readonly [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: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>;
+    all<T1, T2, T3>(values: readonly [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: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>;
+    all<T1, T2>(values: readonly [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: readonly (T | PromiseLike<T>)[]): Promise<T[]>;
+    all<T>(values: readonly 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<T>(values: readonly T[]): Promise<T extends PromiseLike<infer U> ? U : T>;
+    race<T>(values: readonly T[]): Promise<awaited T>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -106,21 +106,21 @@ interface PromiseConstructor {
      * @param values An iterable of Promises.
      * @returns A new Promise.
      */
-    race<T>(values: Iterable<T>): Promise<T extends PromiseLike<infer U> ? U : T>;
+    race<T>(values: Iterable<T>): Promise<awaited T>;
 
     /**
      * Creates a new rejected promise for the provided reason.
      * @param reason The reason the promise was rejected.
      * @returns A new rejected Promise.
      */
-    reject<T = never>(reason?: any): Promise<T>;
+    reject<T = never>(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 8c11be587a1..d8d13da5de5 100644
--- a/src/lib/es5.d.ts
+++ b/src/lib/es5.d.ts
@@ -1387,7 +1387,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>;
 }
 
 /**
@@ -1400,14 +1400,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/src/services/codefixes/inferFromUsage.ts b/src/services/codefixes/inferFromUsage.ts
index 5718f592cb8..b704b78bc7f 100644
--- a/src/services/codefixes/inferFromUsage.ts
+++ b/src/services/codefixes/inferFromUsage.ts
@@ -1050,6 +1050,9 @@ namespace ts.codefix {
             else if (genericType.flags & TypeFlags.UnionOrIntersection) {
                 return flatMap((genericType as UnionOrIntersectionType).types, t => inferTypeParameters(t, usageType, typeParameter));
             }
+            else if (genericType.flags & TypeFlags.Awaited) {
+                return inferTypeParameters((<AwaitedType>genericType).typeVariable, usageType, typeParameter);
+            }
             else if (getObjectFlags(genericType) & ObjectFlags.Reference && getObjectFlags(usageType) & ObjectFlags.Reference) {
                 // this is wrong because we need a reference to the targetType to, so we can check that it's also a reference
                 const genericArgs = checker.getTypeArguments(genericType as TypeReference);
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index 0ac0f4c227e..4c5ad114dab 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -71,7 +71,7 @@ declare namespace ts {
         end: number;
     }
     export type JSDocSyntaxKind = SyntaxKind.EndOfFileToken | SyntaxKind.WhitespaceTrivia | SyntaxKind.AtToken | SyntaxKind.NewLineTrivia | SyntaxKind.AsteriskToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.EqualsToken | SyntaxKind.CommaToken | SyntaxKind.DotToken | SyntaxKind.Identifier | SyntaxKind.BacktickToken | SyntaxKind.Unknown | KeywordSyntaxKind;
-    export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InKeyword | SyntaxKind.InferKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.OfKeyword;
+    export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InKeyword | SyntaxKind.InferKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.AwaitedKeyword | SyntaxKind.OfKeyword;
     export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;
     export enum SyntaxKind {
         Unknown = 0,
@@ -203,209 +203,210 @@ declare namespace ts {
         AnyKeyword = 125,
         AsyncKeyword = 126,
         AwaitKeyword = 127,
-        BooleanKeyword = 128,
-        ConstructorKeyword = 129,
-        DeclareKeyword = 130,
-        GetKeyword = 131,
-        InferKeyword = 132,
-        IsKeyword = 133,
-        KeyOfKeyword = 134,
-        ModuleKeyword = 135,
-        NamespaceKeyword = 136,
-        NeverKeyword = 137,
-        ReadonlyKeyword = 138,
-        RequireKeyword = 139,
-        NumberKeyword = 140,
-        ObjectKeyword = 141,
-        SetKeyword = 142,
-        StringKeyword = 143,
-        SymbolKeyword = 144,
-        TypeKeyword = 145,
-        UndefinedKeyword = 146,
-        UniqueKeyword = 147,
-        UnknownKeyword = 148,
-        FromKeyword = 149,
-        GlobalKeyword = 150,
-        BigIntKeyword = 151,
-        OfKeyword = 152,
-        QualifiedName = 153,
-        ComputedPropertyName = 154,
-        TypeParameter = 155,
-        Parameter = 156,
-        Decorator = 157,
-        PropertySignature = 158,
-        PropertyDeclaration = 159,
-        MethodSignature = 160,
-        MethodDeclaration = 161,
-        Constructor = 162,
-        GetAccessor = 163,
-        SetAccessor = 164,
-        CallSignature = 165,
-        ConstructSignature = 166,
-        IndexSignature = 167,
-        TypePredicate = 168,
-        TypeReference = 169,
-        FunctionType = 170,
-        ConstructorType = 171,
-        TypeQuery = 172,
-        TypeLiteral = 173,
-        ArrayType = 174,
-        TupleType = 175,
-        OptionalType = 176,
-        RestType = 177,
-        UnionType = 178,
-        IntersectionType = 179,
-        ConditionalType = 180,
-        InferType = 181,
-        ParenthesizedType = 182,
-        ThisType = 183,
-        TypeOperator = 184,
-        IndexedAccessType = 185,
-        MappedType = 186,
-        LiteralType = 187,
-        ImportType = 188,
-        ObjectBindingPattern = 189,
-        ArrayBindingPattern = 190,
-        BindingElement = 191,
-        ArrayLiteralExpression = 192,
-        ObjectLiteralExpression = 193,
-        PropertyAccessExpression = 194,
-        ElementAccessExpression = 195,
-        CallExpression = 196,
-        NewExpression = 197,
-        TaggedTemplateExpression = 198,
-        TypeAssertionExpression = 199,
-        ParenthesizedExpression = 200,
-        FunctionExpression = 201,
-        ArrowFunction = 202,
-        DeleteExpression = 203,
-        TypeOfExpression = 204,
-        VoidExpression = 205,
-        AwaitExpression = 206,
-        PrefixUnaryExpression = 207,
-        PostfixUnaryExpression = 208,
-        BinaryExpression = 209,
-        ConditionalExpression = 210,
-        TemplateExpression = 211,
-        YieldExpression = 212,
-        SpreadElement = 213,
-        ClassExpression = 214,
-        OmittedExpression = 215,
-        ExpressionWithTypeArguments = 216,
-        AsExpression = 217,
-        NonNullExpression = 218,
-        MetaProperty = 219,
-        SyntheticExpression = 220,
-        TemplateSpan = 221,
-        SemicolonClassElement = 222,
-        Block = 223,
-        EmptyStatement = 224,
-        VariableStatement = 225,
-        ExpressionStatement = 226,
-        IfStatement = 227,
-        DoStatement = 228,
-        WhileStatement = 229,
-        ForStatement = 230,
-        ForInStatement = 231,
-        ForOfStatement = 232,
-        ContinueStatement = 233,
-        BreakStatement = 234,
-        ReturnStatement = 235,
-        WithStatement = 236,
-        SwitchStatement = 237,
-        LabeledStatement = 238,
-        ThrowStatement = 239,
-        TryStatement = 240,
-        DebuggerStatement = 241,
-        VariableDeclaration = 242,
-        VariableDeclarationList = 243,
-        FunctionDeclaration = 244,
-        ClassDeclaration = 245,
-        InterfaceDeclaration = 246,
-        TypeAliasDeclaration = 247,
-        EnumDeclaration = 248,
-        ModuleDeclaration = 249,
-        ModuleBlock = 250,
-        CaseBlock = 251,
-        NamespaceExportDeclaration = 252,
-        ImportEqualsDeclaration = 253,
-        ImportDeclaration = 254,
-        ImportClause = 255,
-        NamespaceImport = 256,
-        NamedImports = 257,
-        ImportSpecifier = 258,
-        ExportAssignment = 259,
-        ExportDeclaration = 260,
-        NamedExports = 261,
-        NamespaceExport = 262,
-        ExportSpecifier = 263,
-        MissingDeclaration = 264,
-        ExternalModuleReference = 265,
-        JsxElement = 266,
-        JsxSelfClosingElement = 267,
-        JsxOpeningElement = 268,
-        JsxClosingElement = 269,
-        JsxFragment = 270,
-        JsxOpeningFragment = 271,
-        JsxClosingFragment = 272,
-        JsxAttribute = 273,
-        JsxAttributes = 274,
-        JsxSpreadAttribute = 275,
-        JsxExpression = 276,
-        CaseClause = 277,
-        DefaultClause = 278,
-        HeritageClause = 279,
-        CatchClause = 280,
-        PropertyAssignment = 281,
-        ShorthandPropertyAssignment = 282,
-        SpreadAssignment = 283,
-        EnumMember = 284,
-        UnparsedPrologue = 285,
-        UnparsedPrepend = 286,
-        UnparsedText = 287,
-        UnparsedInternalText = 288,
-        UnparsedSyntheticReference = 289,
-        SourceFile = 290,
-        Bundle = 291,
-        UnparsedSource = 292,
-        InputFiles = 293,
-        JSDocTypeExpression = 294,
-        JSDocAllType = 295,
-        JSDocUnknownType = 296,
-        JSDocNullableType = 297,
-        JSDocNonNullableType = 298,
-        JSDocOptionalType = 299,
-        JSDocFunctionType = 300,
-        JSDocVariadicType = 301,
-        JSDocNamepathType = 302,
-        JSDocComment = 303,
-        JSDocTypeLiteral = 304,
-        JSDocSignature = 305,
-        JSDocTag = 306,
-        JSDocAugmentsTag = 307,
-        JSDocAuthorTag = 308,
-        JSDocClassTag = 309,
-        JSDocPublicTag = 310,
-        JSDocPrivateTag = 311,
-        JSDocProtectedTag = 312,
-        JSDocReadonlyTag = 313,
-        JSDocCallbackTag = 314,
-        JSDocEnumTag = 315,
-        JSDocParameterTag = 316,
-        JSDocReturnTag = 317,
-        JSDocThisTag = 318,
-        JSDocTypeTag = 319,
-        JSDocTemplateTag = 320,
-        JSDocTypedefTag = 321,
-        JSDocPropertyTag = 322,
-        SyntaxList = 323,
-        NotEmittedStatement = 324,
-        PartiallyEmittedExpression = 325,
-        CommaListExpression = 326,
-        MergeDeclarationMarker = 327,
-        EndOfDeclarationMarker = 328,
-        SyntheticReferenceExpression = 329,
-        Count = 330,
+        AwaitedKeyword = 128,
+        BooleanKeyword = 129,
+        ConstructorKeyword = 130,
+        DeclareKeyword = 131,
+        GetKeyword = 132,
+        InferKeyword = 133,
+        IsKeyword = 134,
+        KeyOfKeyword = 135,
+        ModuleKeyword = 136,
+        NamespaceKeyword = 137,
+        NeverKeyword = 138,
+        ReadonlyKeyword = 139,
+        RequireKeyword = 140,
+        NumberKeyword = 141,
+        ObjectKeyword = 142,
+        SetKeyword = 143,
+        StringKeyword = 144,
+        SymbolKeyword = 145,
+        TypeKeyword = 146,
+        UndefinedKeyword = 147,
+        UniqueKeyword = 148,
+        UnknownKeyword = 149,
+        FromKeyword = 150,
+        GlobalKeyword = 151,
+        BigIntKeyword = 152,
+        OfKeyword = 153,
+        QualifiedName = 154,
+        ComputedPropertyName = 155,
+        TypeParameter = 156,
+        Parameter = 157,
+        Decorator = 158,
+        PropertySignature = 159,
+        PropertyDeclaration = 160,
+        MethodSignature = 161,
+        MethodDeclaration = 162,
+        Constructor = 163,
+        GetAccessor = 164,
+        SetAccessor = 165,
+        CallSignature = 166,
+        ConstructSignature = 167,
+        IndexSignature = 168,
+        TypePredicate = 169,
+        TypeReference = 170,
+        FunctionType = 171,
+        ConstructorType = 172,
+        TypeQuery = 173,
+        TypeLiteral = 174,
+        ArrayType = 175,
+        TupleType = 176,
+        OptionalType = 177,
+        RestType = 178,
+        UnionType = 179,
+        IntersectionType = 180,
+        ConditionalType = 181,
+        InferType = 182,
+        ParenthesizedType = 183,
+        ThisType = 184,
+        TypeOperator = 185,
+        IndexedAccessType = 186,
+        MappedType = 187,
+        LiteralType = 188,
+        ImportType = 189,
+        ObjectBindingPattern = 190,
+        ArrayBindingPattern = 191,
+        BindingElement = 192,
+        ArrayLiteralExpression = 193,
+        ObjectLiteralExpression = 194,
+        PropertyAccessExpression = 195,
+        ElementAccessExpression = 196,
+        CallExpression = 197,
+        NewExpression = 198,
+        TaggedTemplateExpression = 199,
+        TypeAssertionExpression = 200,
+        ParenthesizedExpression = 201,
+        FunctionExpression = 202,
+        ArrowFunction = 203,
+        DeleteExpression = 204,
+        TypeOfExpression = 205,
+        VoidExpression = 206,
+        AwaitExpression = 207,
+        PrefixUnaryExpression = 208,
+        PostfixUnaryExpression = 209,
+        BinaryExpression = 210,
+        ConditionalExpression = 211,
+        TemplateExpression = 212,
+        YieldExpression = 213,
+        SpreadElement = 214,
+        ClassExpression = 215,
+        OmittedExpression = 216,
+        ExpressionWithTypeArguments = 217,
+        AsExpression = 218,
+        NonNullExpression = 219,
+        MetaProperty = 220,
+        SyntheticExpression = 221,
+        TemplateSpan = 222,
+        SemicolonClassElement = 223,
+        Block = 224,
+        EmptyStatement = 225,
+        VariableStatement = 226,
+        ExpressionStatement = 227,
+        IfStatement = 228,
+        DoStatement = 229,
+        WhileStatement = 230,
+        ForStatement = 231,
+        ForInStatement = 232,
+        ForOfStatement = 233,
+        ContinueStatement = 234,
+        BreakStatement = 235,
+        ReturnStatement = 236,
+        WithStatement = 237,
+        SwitchStatement = 238,
+        LabeledStatement = 239,
+        ThrowStatement = 240,
+        TryStatement = 241,
+        DebuggerStatement = 242,
+        VariableDeclaration = 243,
+        VariableDeclarationList = 244,
+        FunctionDeclaration = 245,
+        ClassDeclaration = 246,
+        InterfaceDeclaration = 247,
+        TypeAliasDeclaration = 248,
+        EnumDeclaration = 249,
+        ModuleDeclaration = 250,
+        ModuleBlock = 251,
+        CaseBlock = 252,
+        NamespaceExportDeclaration = 253,
+        ImportEqualsDeclaration = 254,
+        ImportDeclaration = 255,
+        ImportClause = 256,
+        NamespaceImport = 257,
+        NamedImports = 258,
+        ImportSpecifier = 259,
+        ExportAssignment = 260,
+        ExportDeclaration = 261,
+        NamedExports = 262,
+        NamespaceExport = 263,
+        ExportSpecifier = 264,
+        MissingDeclaration = 265,
+        ExternalModuleReference = 266,
+        JsxElement = 267,
+        JsxSelfClosingElement = 268,
+        JsxOpeningElement = 269,
+        JsxClosingElement = 270,
+        JsxFragment = 271,
+        JsxOpeningFragment = 272,
+        JsxClosingFragment = 273,
+        JsxAttribute = 274,
+        JsxAttributes = 275,
+        JsxSpreadAttribute = 276,
+        JsxExpression = 277,
+        CaseClause = 278,
+        DefaultClause = 279,
+        HeritageClause = 280,
+        CatchClause = 281,
+        PropertyAssignment = 282,
+        ShorthandPropertyAssignment = 283,
+        SpreadAssignment = 284,
+        EnumMember = 285,
+        UnparsedPrologue = 286,
+        UnparsedPrepend = 287,
+        UnparsedText = 288,
+        UnparsedInternalText = 289,
+        UnparsedSyntheticReference = 290,
+        SourceFile = 291,
+        Bundle = 292,
+        UnparsedSource = 293,
+        InputFiles = 294,
+        JSDocTypeExpression = 295,
+        JSDocAllType = 296,
+        JSDocUnknownType = 297,
+        JSDocNullableType = 298,
+        JSDocNonNullableType = 299,
+        JSDocOptionalType = 300,
+        JSDocFunctionType = 301,
+        JSDocVariadicType = 302,
+        JSDocNamepathType = 303,
+        JSDocComment = 304,
+        JSDocTypeLiteral = 305,
+        JSDocSignature = 306,
+        JSDocTag = 307,
+        JSDocAugmentsTag = 308,
+        JSDocAuthorTag = 309,
+        JSDocClassTag = 310,
+        JSDocPublicTag = 311,
+        JSDocPrivateTag = 312,
+        JSDocProtectedTag = 313,
+        JSDocReadonlyTag = 314,
+        JSDocCallbackTag = 315,
+        JSDocEnumTag = 316,
+        JSDocParameterTag = 317,
+        JSDocReturnTag = 318,
+        JSDocThisTag = 319,
+        JSDocTypeTag = 320,
+        JSDocTemplateTag = 321,
+        JSDocTypedefTag = 322,
+        JSDocPropertyTag = 323,
+        SyntaxList = 324,
+        NotEmittedStatement = 325,
+        PartiallyEmittedExpression = 326,
+        CommaListExpression = 327,
+        MergeDeclarationMarker = 328,
+        EndOfDeclarationMarker = 329,
+        SyntheticReferenceExpression = 330,
+        Count = 331,
         FirstAssignment = 62,
         LastAssignment = 74,
         FirstCompoundAssignment = 63,
@@ -413,15 +414,15 @@ declare namespace ts {
         FirstReservedWord = 77,
         LastReservedWord = 112,
         FirstKeyword = 77,
-        LastKeyword = 152,
+        LastKeyword = 153,
         FirstFutureReservedWord = 113,
         LastFutureReservedWord = 121,
-        FirstTypeNode = 168,
-        LastTypeNode = 188,
+        FirstTypeNode = 169,
+        LastTypeNode = 189,
         FirstPunctuation = 18,
         LastPunctuation = 74,
         FirstToken = 0,
-        LastToken = 152,
+        LastToken = 153,
         FirstTriviaToken = 2,
         LastTriviaToken = 7,
         FirstLiteralToken = 8,
@@ -430,13 +431,13 @@ declare namespace ts {
         LastTemplateToken = 17,
         FirstBinaryOperator = 29,
         LastBinaryOperator = 74,
-        FirstStatement = 225,
-        LastStatement = 241,
-        FirstNode = 153,
-        FirstJSDocNode = 294,
-        LastJSDocNode = 322,
-        FirstJSDocTagNode = 306,
-        LastJSDocTagNode = 322,
+        FirstStatement = 226,
+        LastStatement = 242,
+        FirstNode = 154,
+        FirstJSDocNode = 295,
+        LastJSDocNode = 323,
+        FirstJSDocTagNode = 307,
+        LastJSDocTagNode = 323,
     }
     export enum NodeFlags {
         None = 0,
@@ -843,7 +844,7 @@ declare namespace ts {
     }
     export interface TypeOperatorNode extends TypeNode {
         kind: SyntaxKind.TypeOperator;
-        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
+        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword;
         type: TypeNode;
     }
     export interface IndexedAccessTypeNode extends TypeNode {
@@ -2342,6 +2343,7 @@ declare namespace ts {
         Conditional = 16777216,
         Substitution = 33554432,
         NonPrimitive = 67108864,
+        Awaited = 134217728,
         Literal = 2944,
         Unit = 109440,
         StringOrNumberLiteral = 384,
@@ -2356,11 +2358,11 @@ declare namespace ts {
         UnionOrIntersection = 3145728,
         StructuredType = 3670016,
         TypeVariable = 8650752,
-        InstantiableNonPrimitive = 58982400,
+        InstantiableNonPrimitive = 193200128,
         InstantiablePrimitive = 4194304,
-        Instantiable = 63176704,
-        StructuredOrInstantiable = 66846720,
-        Narrowable = 133970943,
+        Instantiable = 197394432,
+        StructuredOrInstantiable = 201064448,
+        Narrowable = 268188671,
         NotUnionOrUnit = 67637251,
     }
     export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
@@ -2508,6 +2510,9 @@ declare namespace ts {
         typeVariable: TypeVariable;
         substitute: Type;
     }
+    export interface AwaitedType extends InstantiableType {
+        typeVariable: TypeVariable;
+    }
     export enum SignatureKind {
         Call = 0,
         Construct = 1
@@ -4024,7 +4029,7 @@ declare namespace ts {
     function updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode;
     function createThisTypeNode(): ThisTypeNode;
     function createTypeOperatorNode(type: TypeNode): TypeOperatorNode;
-    function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
+    function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword, type: TypeNode): TypeOperatorNode;
     function updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode): TypeOperatorNode;
     function createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
     function updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index 42432eac6e7..94e3668fc54 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -71,7 +71,7 @@ declare namespace ts {
         end: number;
     }
     export type JSDocSyntaxKind = SyntaxKind.EndOfFileToken | SyntaxKind.WhitespaceTrivia | SyntaxKind.AtToken | SyntaxKind.NewLineTrivia | SyntaxKind.AsteriskToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.EqualsToken | SyntaxKind.CommaToken | SyntaxKind.DotToken | SyntaxKind.Identifier | SyntaxKind.BacktickToken | SyntaxKind.Unknown | KeywordSyntaxKind;
-    export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InKeyword | SyntaxKind.InferKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.OfKeyword;
+    export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InKeyword | SyntaxKind.InferKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.RequireKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.AwaitedKeyword | SyntaxKind.OfKeyword;
     export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;
     export enum SyntaxKind {
         Unknown = 0,
@@ -203,209 +203,210 @@ declare namespace ts {
         AnyKeyword = 125,
         AsyncKeyword = 126,
         AwaitKeyword = 127,
-        BooleanKeyword = 128,
-        ConstructorKeyword = 129,
-        DeclareKeyword = 130,
-        GetKeyword = 131,
-        InferKeyword = 132,
-        IsKeyword = 133,
-        KeyOfKeyword = 134,
-        ModuleKeyword = 135,
-        NamespaceKeyword = 136,
-        NeverKeyword = 137,
-        ReadonlyKeyword = 138,
-        RequireKeyword = 139,
-        NumberKeyword = 140,
-        ObjectKeyword = 141,
-        SetKeyword = 142,
-        StringKeyword = 143,
-        SymbolKeyword = 144,
-        TypeKeyword = 145,
-        UndefinedKeyword = 146,
-        UniqueKeyword = 147,
-        UnknownKeyword = 148,
-        FromKeyword = 149,
-        GlobalKeyword = 150,
-        BigIntKeyword = 151,
-        OfKeyword = 152,
-        QualifiedName = 153,
-        ComputedPropertyName = 154,
-        TypeParameter = 155,
-        Parameter = 156,
-        Decorator = 157,
-        PropertySignature = 158,
-        PropertyDeclaration = 159,
-        MethodSignature = 160,
-        MethodDeclaration = 161,
-        Constructor = 162,
-        GetAccessor = 163,
-        SetAccessor = 164,
-        CallSignature = 165,
-        ConstructSignature = 166,
-        IndexSignature = 167,
-        TypePredicate = 168,
-        TypeReference = 169,
-        FunctionType = 170,
-        ConstructorType = 171,
-        TypeQuery = 172,
-        TypeLiteral = 173,
-        ArrayType = 174,
-        TupleType = 175,
-        OptionalType = 176,
-        RestType = 177,
-        UnionType = 178,
-        IntersectionType = 179,
-        ConditionalType = 180,
-        InferType = 181,
-        ParenthesizedType = 182,
-        ThisType = 183,
-        TypeOperator = 184,
-        IndexedAccessType = 185,
-        MappedType = 186,
-        LiteralType = 187,
-        ImportType = 188,
-        ObjectBindingPattern = 189,
-        ArrayBindingPattern = 190,
-        BindingElement = 191,
-        ArrayLiteralExpression = 192,
-        ObjectLiteralExpression = 193,
-        PropertyAccessExpression = 194,
-        ElementAccessExpression = 195,
-        CallExpression = 196,
-        NewExpression = 197,
-        TaggedTemplateExpression = 198,
-        TypeAssertionExpression = 199,
-        ParenthesizedExpression = 200,
-        FunctionExpression = 201,
-        ArrowFunction = 202,
-        DeleteExpression = 203,
-        TypeOfExpression = 204,
-        VoidExpression = 205,
-        AwaitExpression = 206,
-        PrefixUnaryExpression = 207,
-        PostfixUnaryExpression = 208,
-        BinaryExpression = 209,
-        ConditionalExpression = 210,
-        TemplateExpression = 211,
-        YieldExpression = 212,
-        SpreadElement = 213,
-        ClassExpression = 214,
-        OmittedExpression = 215,
-        ExpressionWithTypeArguments = 216,
-        AsExpression = 217,
-        NonNullExpression = 218,
-        MetaProperty = 219,
-        SyntheticExpression = 220,
-        TemplateSpan = 221,
-        SemicolonClassElement = 222,
-        Block = 223,
-        EmptyStatement = 224,
-        VariableStatement = 225,
-        ExpressionStatement = 226,
-        IfStatement = 227,
-        DoStatement = 228,
-        WhileStatement = 229,
-        ForStatement = 230,
-        ForInStatement = 231,
-        ForOfStatement = 232,
-        ContinueStatement = 233,
-        BreakStatement = 234,
-        ReturnStatement = 235,
-        WithStatement = 236,
-        SwitchStatement = 237,
-        LabeledStatement = 238,
-        ThrowStatement = 239,
-        TryStatement = 240,
-        DebuggerStatement = 241,
-        VariableDeclaration = 242,
-        VariableDeclarationList = 243,
-        FunctionDeclaration = 244,
-        ClassDeclaration = 245,
-        InterfaceDeclaration = 246,
-        TypeAliasDeclaration = 247,
-        EnumDeclaration = 248,
-        ModuleDeclaration = 249,
-        ModuleBlock = 250,
-        CaseBlock = 251,
-        NamespaceExportDeclaration = 252,
-        ImportEqualsDeclaration = 253,
-        ImportDeclaration = 254,
-        ImportClause = 255,
-        NamespaceImport = 256,
-        NamedImports = 257,
-        ImportSpecifier = 258,
-        ExportAssignment = 259,
-        ExportDeclaration = 260,
-        NamedExports = 261,
-        NamespaceExport = 262,
-        ExportSpecifier = 263,
-        MissingDeclaration = 264,
-        ExternalModuleReference = 265,
-        JsxElement = 266,
-        JsxSelfClosingElement = 267,
-        JsxOpeningElement = 268,
-        JsxClosingElement = 269,
-        JsxFragment = 270,
-        JsxOpeningFragment = 271,
-        JsxClosingFragment = 272,
-        JsxAttribute = 273,
-        JsxAttributes = 274,
-        JsxSpreadAttribute = 275,
-        JsxExpression = 276,
-        CaseClause = 277,
-        DefaultClause = 278,
-        HeritageClause = 279,
-        CatchClause = 280,
-        PropertyAssignment = 281,
-        ShorthandPropertyAssignment = 282,
-        SpreadAssignment = 283,
-        EnumMember = 284,
-        UnparsedPrologue = 285,
-        UnparsedPrepend = 286,
-        UnparsedText = 287,
-        UnparsedInternalText = 288,
-        UnparsedSyntheticReference = 289,
-        SourceFile = 290,
-        Bundle = 291,
-        UnparsedSource = 292,
-        InputFiles = 293,
-        JSDocTypeExpression = 294,
-        JSDocAllType = 295,
-        JSDocUnknownType = 296,
-        JSDocNullableType = 297,
-        JSDocNonNullableType = 298,
-        JSDocOptionalType = 299,
-        JSDocFunctionType = 300,
-        JSDocVariadicType = 301,
-        JSDocNamepathType = 302,
-        JSDocComment = 303,
-        JSDocTypeLiteral = 304,
-        JSDocSignature = 305,
-        JSDocTag = 306,
-        JSDocAugmentsTag = 307,
-        JSDocAuthorTag = 308,
-        JSDocClassTag = 309,
-        JSDocPublicTag = 310,
-        JSDocPrivateTag = 311,
-        JSDocProtectedTag = 312,
-        JSDocReadonlyTag = 313,
-        JSDocCallbackTag = 314,
-        JSDocEnumTag = 315,
-        JSDocParameterTag = 316,
-        JSDocReturnTag = 317,
-        JSDocThisTag = 318,
-        JSDocTypeTag = 319,
-        JSDocTemplateTag = 320,
-        JSDocTypedefTag = 321,
-        JSDocPropertyTag = 322,
-        SyntaxList = 323,
-        NotEmittedStatement = 324,
-        PartiallyEmittedExpression = 325,
-        CommaListExpression = 326,
-        MergeDeclarationMarker = 327,
-        EndOfDeclarationMarker = 328,
-        SyntheticReferenceExpression = 329,
-        Count = 330,
+        AwaitedKeyword = 128,
+        BooleanKeyword = 129,
+        ConstructorKeyword = 130,
+        DeclareKeyword = 131,
+        GetKeyword = 132,
+        InferKeyword = 133,
+        IsKeyword = 134,
+        KeyOfKeyword = 135,
+        ModuleKeyword = 136,
+        NamespaceKeyword = 137,
+        NeverKeyword = 138,
+        ReadonlyKeyword = 139,
+        RequireKeyword = 140,
+        NumberKeyword = 141,
+        ObjectKeyword = 142,
+        SetKeyword = 143,
+        StringKeyword = 144,
+        SymbolKeyword = 145,
+        TypeKeyword = 146,
+        UndefinedKeyword = 147,
+        UniqueKeyword = 148,
+        UnknownKeyword = 149,
+        FromKeyword = 150,
+        GlobalKeyword = 151,
+        BigIntKeyword = 152,
+        OfKeyword = 153,
+        QualifiedName = 154,
+        ComputedPropertyName = 155,
+        TypeParameter = 156,
+        Parameter = 157,
+        Decorator = 158,
+        PropertySignature = 159,
+        PropertyDeclaration = 160,
+        MethodSignature = 161,
+        MethodDeclaration = 162,
+        Constructor = 163,
+        GetAccessor = 164,
+        SetAccessor = 165,
+        CallSignature = 166,
+        ConstructSignature = 167,
+        IndexSignature = 168,
+        TypePredicate = 169,
+        TypeReference = 170,
+        FunctionType = 171,
+        ConstructorType = 172,
+        TypeQuery = 173,
+        TypeLiteral = 174,
+        ArrayType = 175,
+        TupleType = 176,
+        OptionalType = 177,
+        RestType = 178,
+        UnionType = 179,
+        IntersectionType = 180,
+        ConditionalType = 181,
+        InferType = 182,
+        ParenthesizedType = 183,
+        ThisType = 184,
+        TypeOperator = 185,
+        IndexedAccessType = 186,
+        MappedType = 187,
+        LiteralType = 188,
+        ImportType = 189,
+        ObjectBindingPattern = 190,
+        ArrayBindingPattern = 191,
+        BindingElement = 192,
+        ArrayLiteralExpression = 193,
+        ObjectLiteralExpression = 194,
+        PropertyAccessExpression = 195,
+        ElementAccessExpression = 196,
+        CallExpression = 197,
+        NewExpression = 198,
+        TaggedTemplateExpression = 199,
+        TypeAssertionExpression = 200,
+        ParenthesizedExpression = 201,
+        FunctionExpression = 202,
+        ArrowFunction = 203,
+        DeleteExpression = 204,
+        TypeOfExpression = 205,
+        VoidExpression = 206,
+        AwaitExpression = 207,
+        PrefixUnaryExpression = 208,
+        PostfixUnaryExpression = 209,
+        BinaryExpression = 210,
+        ConditionalExpression = 211,
+        TemplateExpression = 212,
+        YieldExpression = 213,
+        SpreadElement = 214,
+        ClassExpression = 215,
+        OmittedExpression = 216,
+        ExpressionWithTypeArguments = 217,
+        AsExpression = 218,
+        NonNullExpression = 219,
+        MetaProperty = 220,
+        SyntheticExpression = 221,
+        TemplateSpan = 222,
+        SemicolonClassElement = 223,
+        Block = 224,
+        EmptyStatement = 225,
+        VariableStatement = 226,
+        ExpressionStatement = 227,
+        IfStatement = 228,
+        DoStatement = 229,
+        WhileStatement = 230,
+        ForStatement = 231,
+        ForInStatement = 232,
+        ForOfStatement = 233,
+        ContinueStatement = 234,
+        BreakStatement = 235,
+        ReturnStatement = 236,
+        WithStatement = 237,
+        SwitchStatement = 238,
+        LabeledStatement = 239,
+        ThrowStatement = 240,
+        TryStatement = 241,
+        DebuggerStatement = 242,
+        VariableDeclaration = 243,
+        VariableDeclarationList = 244,
+        FunctionDeclaration = 245,
+        ClassDeclaration = 246,
+        InterfaceDeclaration = 247,
+        TypeAliasDeclaration = 248,
+        EnumDeclaration = 249,
+        ModuleDeclaration = 250,
+        ModuleBlock = 251,
+        CaseBlock = 252,
+        NamespaceExportDeclaration = 253,
+        ImportEqualsDeclaration = 254,
+        ImportDeclaration = 255,
+        ImportClause = 256,
+        NamespaceImport = 257,
+        NamedImports = 258,
+        ImportSpecifier = 259,
+        ExportAssignment = 260,
+        ExportDeclaration = 261,
+        NamedExports = 262,
+        NamespaceExport = 263,
+        ExportSpecifier = 264,
+        MissingDeclaration = 265,
+        ExternalModuleReference = 266,
+        JsxElement = 267,
+        JsxSelfClosingElement = 268,
+        JsxOpeningElement = 269,
+        JsxClosingElement = 270,
+        JsxFragment = 271,
+        JsxOpeningFragment = 272,
+        JsxClosingFragment = 273,
+        JsxAttribute = 274,
+        JsxAttributes = 275,
+        JsxSpreadAttribute = 276,
+        JsxExpression = 277,
+        CaseClause = 278,
+        DefaultClause = 279,
+        HeritageClause = 280,
+        CatchClause = 281,
+        PropertyAssignment = 282,
+        ShorthandPropertyAssignment = 283,
+        SpreadAssignment = 284,
+        EnumMember = 285,
+        UnparsedPrologue = 286,
+        UnparsedPrepend = 287,
+        UnparsedText = 288,
+        UnparsedInternalText = 289,
+        UnparsedSyntheticReference = 290,
+        SourceFile = 291,
+        Bundle = 292,
+        UnparsedSource = 293,
+        InputFiles = 294,
+        JSDocTypeExpression = 295,
+        JSDocAllType = 296,
+        JSDocUnknownType = 297,
+        JSDocNullableType = 298,
+        JSDocNonNullableType = 299,
+        JSDocOptionalType = 300,
+        JSDocFunctionType = 301,
+        JSDocVariadicType = 302,
+        JSDocNamepathType = 303,
+        JSDocComment = 304,
+        JSDocTypeLiteral = 305,
+        JSDocSignature = 306,
+        JSDocTag = 307,
+        JSDocAugmentsTag = 308,
+        JSDocAuthorTag = 309,
+        JSDocClassTag = 310,
+        JSDocPublicTag = 311,
+        JSDocPrivateTag = 312,
+        JSDocProtectedTag = 313,
+        JSDocReadonlyTag = 314,
+        JSDocCallbackTag = 315,
+        JSDocEnumTag = 316,
+        JSDocParameterTag = 317,
+        JSDocReturnTag = 318,
+        JSDocThisTag = 319,
+        JSDocTypeTag = 320,
+        JSDocTemplateTag = 321,
+        JSDocTypedefTag = 322,
+        JSDocPropertyTag = 323,
+        SyntaxList = 324,
+        NotEmittedStatement = 325,
+        PartiallyEmittedExpression = 326,
+        CommaListExpression = 327,
+        MergeDeclarationMarker = 328,
+        EndOfDeclarationMarker = 329,
+        SyntheticReferenceExpression = 330,
+        Count = 331,
         FirstAssignment = 62,
         LastAssignment = 74,
         FirstCompoundAssignment = 63,
@@ -413,15 +414,15 @@ declare namespace ts {
         FirstReservedWord = 77,
         LastReservedWord = 112,
         FirstKeyword = 77,
-        LastKeyword = 152,
+        LastKeyword = 153,
         FirstFutureReservedWord = 113,
         LastFutureReservedWord = 121,
-        FirstTypeNode = 168,
-        LastTypeNode = 188,
+        FirstTypeNode = 169,
+        LastTypeNode = 189,
         FirstPunctuation = 18,
         LastPunctuation = 74,
         FirstToken = 0,
-        LastToken = 152,
+        LastToken = 153,
         FirstTriviaToken = 2,
         LastTriviaToken = 7,
         FirstLiteralToken = 8,
@@ -430,13 +431,13 @@ declare namespace ts {
         LastTemplateToken = 17,
         FirstBinaryOperator = 29,
         LastBinaryOperator = 74,
-        FirstStatement = 225,
-        LastStatement = 241,
-        FirstNode = 153,
-        FirstJSDocNode = 294,
-        LastJSDocNode = 322,
-        FirstJSDocTagNode = 306,
-        LastJSDocTagNode = 322,
+        FirstStatement = 226,
+        LastStatement = 242,
+        FirstNode = 154,
+        FirstJSDocNode = 295,
+        LastJSDocNode = 323,
+        FirstJSDocTagNode = 307,
+        LastJSDocTagNode = 323,
     }
     export enum NodeFlags {
         None = 0,
@@ -843,7 +844,7 @@ declare namespace ts {
     }
     export interface TypeOperatorNode extends TypeNode {
         kind: SyntaxKind.TypeOperator;
-        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
+        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword;
         type: TypeNode;
     }
     export interface IndexedAccessTypeNode extends TypeNode {
@@ -2342,6 +2343,7 @@ declare namespace ts {
         Conditional = 16777216,
         Substitution = 33554432,
         NonPrimitive = 67108864,
+        Awaited = 134217728,
         Literal = 2944,
         Unit = 109440,
         StringOrNumberLiteral = 384,
@@ -2356,11 +2358,11 @@ declare namespace ts {
         UnionOrIntersection = 3145728,
         StructuredType = 3670016,
         TypeVariable = 8650752,
-        InstantiableNonPrimitive = 58982400,
+        InstantiableNonPrimitive = 193200128,
         InstantiablePrimitive = 4194304,
-        Instantiable = 63176704,
-        StructuredOrInstantiable = 66846720,
-        Narrowable = 133970943,
+        Instantiable = 197394432,
+        StructuredOrInstantiable = 201064448,
+        Narrowable = 268188671,
         NotUnionOrUnit = 67637251,
     }
     export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
@@ -2508,6 +2510,9 @@ declare namespace ts {
         typeVariable: TypeVariable;
         substitute: Type;
     }
+    export interface AwaitedType extends InstantiableType {
+        typeVariable: TypeVariable;
+    }
     export enum SignatureKind {
         Call = 0,
         Construct = 1
@@ -4024,7 +4029,7 @@ declare namespace ts {
     function updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode;
     function createThisTypeNode(): ThisTypeNode;
     function createTypeOperatorNode(type: TypeNode): TypeOperatorNode;
-    function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
+    function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword, type: TypeNode): TypeOperatorNode;
     function updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode): TypeOperatorNode;
     function createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
     function updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
diff --git a/tests/baselines/reference/asyncArrowFunction11_es5.types b/tests/baselines/reference/asyncArrowFunction11_es5.types
index 7fd9d53af72..7c8c303b1a0 100644
--- a/tests/baselines/reference/asyncArrowFunction11_es5.types
+++ b/tests/baselines/reference/asyncArrowFunction11_es5.types
@@ -11,9 +11,9 @@ class A {
         await Promise.resolve();
 >await Promise.resolve() : void
 >Promise.resolve() : Promise<void>
->Promise.resolve : { <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>; }
 
         const obj = { ["a"]: () => this }; // computed property name after `await` triggers case
 >obj : { a: () => this; }
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es2017.types b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es2017.types
index 57f59302bb5..dbf81dbba27 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 da378ee2718..799c77e77c7 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 5386a956ada..bfab27d8b38 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 7e3595ec6f4..efb23e304fc 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
+++ b/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
@@ -7,7 +7,7 @@ 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.
   Construct signature return types 'Thenable' and 'PromiseLike<T>' are incompatible.
     The types returned by 'then(...)' are incompatible between these types.
-      Type 'void' is not assignable to type 'PromiseLike<TResult1 | 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.
 
@@ -39,7 +39,7 @@ 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:   Construct signature return types 'Thenable' and 'PromiseLike<T>' are incompatible.
 !!! error TS1055:     The types returned by 'then(...)' are incompatible between these types.
-!!! error TS1055:       Type 'void' is not assignable to type 'PromiseLike<TResult1 | 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.js b/tests/baselines/reference/asyncFunctionReturnType.js
index 04b3a04a036..e09d2be92e9 100644
--- a/tests/baselines/reference/asyncFunctionReturnType.js
+++ b/tests/baselines/reference/asyncFunctionReturnType.js
@@ -63,15 +63,15 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
     return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
 }
 
-async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
     return obj[key];
 }
 
-async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
     return Promise.resolve(obj[key]);
 }
 
-async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
     return Promise.resolve<TObj[K]>(obj[key]);
 }
 
diff --git a/tests/baselines/reference/asyncFunctionReturnType.symbols b/tests/baselines/reference/asyncFunctionReturnType.symbols
index 25a7e944c6a..b6c2e5cb5ad 100644
--- a/tests/baselines/reference/asyncFunctionReturnType.symbols
+++ b/tests/baselines/reference/asyncFunctionReturnType.symbols
@@ -221,7 +221,7 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
 >anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 }
 
-async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
 >fGenericIndexedTypeForKProp : Symbol(fGenericIndexedTypeForKProp, Decl(asyncFunctionReturnType.ts, 62, 1))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 64, 43))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
@@ -240,7 +240,7 @@ async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TOb
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 64, 93))
 }
 
-async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
 >fGenericIndexedTypeForPromiseOfKProp : Symbol(fGenericIndexedTypeForPromiseOfKProp, Decl(asyncFunctionReturnType.ts, 66, 1))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 68, 52))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
@@ -262,7 +262,7 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 68, 102))
 }
 
-async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
 >fGenericIndexedTypeForExplicitPromiseOfKProp : Symbol(fGenericIndexedTypeForExplicitPromiseOfKProp, Decl(asyncFunctionReturnType.ts, 70, 1))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 72, 60))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
diff --git a/tests/baselines/reference/asyncFunctionReturnType.types b/tests/baselines/reference/asyncFunctionReturnType.types
index d2cb63e0a35..83878a461c7 100644
--- a/tests/baselines/reference/asyncFunctionReturnType.types
+++ b/tests/baselines/reference/asyncFunctionReturnType.types
@@ -44,9 +44,9 @@ async function fIndexedTypeForPromiseOfStringProp(obj: Obj): Promise<Obj["string
 
     return Promise.resolve(obj.stringProp);
 >Promise.resolve(obj.stringProp) : Promise<string>
->Promise.resolve : { <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
@@ -58,9 +58,9 @@ async function fIndexedTypeForExplicitPromiseOfStringProp(obj: Obj): Promise<Obj
 
     return Promise.resolve<Obj["stringProp"]>(obj.stringProp);
 >Promise.resolve<Obj["stringProp"]>(obj.stringProp) : Promise<string>
->Promise.resolve : { <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
@@ -82,9 +82,9 @@ async function fIndexedTypeForPromiseOfAnyProp(obj: Obj): Promise<Obj["anyProp"]
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve(obj.anyProp) : Promise<any>
->Promise.resolve : { <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
@@ -96,9 +96,9 @@ async function fIndexedTypeForExplicitPromiseOfAnyProp(obj: Obj): Promise<Obj["a
 
     return Promise.resolve<Obj["anyProp"]>(obj.anyProp);
 >Promise.resolve<Obj["anyProp"]>(obj.anyProp) : Promise<any>
->Promise.resolve : { <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
@@ -120,9 +120,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
@@ -133,10 +133,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfStringProp<TObj extends Ob
 >obj : TObj
 
     return Promise.resolve<TObj["stringProp"]>(obj.stringProp);
->Promise.resolve<TObj["stringProp"]>(obj.stringProp) : Promise<TObj["stringProp"]>
->Promise.resolve : { <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>; }
 >obj.stringProp : string
 >obj : TObj
 >stringProp : string
@@ -158,9 +158,9 @@ async function fGenericIndexedTypeForPromiseOfAnyProp<TObj extends Obj>(obj: TOb
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve(obj.anyProp) : Promise<any>
->Promise.resolve : { <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
@@ -171,17 +171,17 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
 >obj : TObj
 
     return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
->Promise.resolve<TObj["anyProp"]>(obj.anyProp) : Promise<TObj["anyProp"]>
->Promise.resolve : { <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>; }
 >obj.anyProp : any
 >obj : TObj
 >anyProp : any
 }
 
-async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
->fGenericIndexedTypeForKProp : <TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K) => Promise<TObj[K]>
+async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
+>fGenericIndexedTypeForKProp : <TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K) => Promise<awaited TObj[K]>
 >obj : TObj
 >key : K
 
@@ -191,31 +191,31 @@ async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TOb
 >key : K
 }
 
-async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
->fGenericIndexedTypeForPromiseOfKProp : <TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K) => Promise<TObj[K]>
+async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
+>fGenericIndexedTypeForPromiseOfKProp : <TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K) => Promise<awaited TObj[K]>
 >obj : TObj
 >key : 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
 }
 
-async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
->fGenericIndexedTypeForExplicitPromiseOfKProp : <TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K) => Promise<TObj[K]>
+async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
+>fGenericIndexedTypeForExplicitPromiseOfKProp : <TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K) => Promise<awaited TObj[K]>
 >obj : TObj
 >key : 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>; }
 >obj[key] : TObj[K]
 >obj : TObj
 >key : K
diff --git a/tests/baselines/reference/awaited.js b/tests/baselines/reference/awaited.js
new file mode 100644
index 00000000000..9def5cd2be2
--- /dev/null
+++ b/tests/baselines/reference/awaited.js
@@ -0,0 +1,209 @@
+//// [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) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(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 00000000000..d8af632541f
--- /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.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.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.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+
+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.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+
+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.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.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, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --))
+
+    });
+}
+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, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --))
+
+    });
+}
+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.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.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.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>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.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.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.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.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.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.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.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.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 00000000000..155a6349ed7
--- /dev/null
+++ b/tests/baselines/reference/awaited.types
@@ -0,0 +1,499 @@
+=== tests/cases/conformance/types/awaited/awaited.ts ===
+// simple
+declare const p0: Promise<number>;
+>p0 : Promise<number>
+
+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>>
+
+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>>
+
+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>
+>x : 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
+
+    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
+
+    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
+
+    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 : <T = never>(reason?: any) => Promise<awaited T>
+>Promise : PromiseConstructor
+>reject : <T = never>(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
+
+    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
+
+    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 : <T = never>(reason?: any) => Promise<awaited T>
+>Promise : PromiseConstructor
+>reject : <T = never>(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 : Promise<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 : Promise<Promise<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
+
+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
+
+    let v0: awaited U;
+>v0 : awaited U
+
+    let v1: awaited Promise<U>;
+>v1 : awaited 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>
+
+    let pu: Promise<U>;
+>pu : Promise<U>
+
+    let v0: awaited U;
+>v0 : awaited U
+
+    let v1: awaited Promise<U>;
+>v1 : awaited 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 a6f2c46782e..d0925d12ac4 100644
--- a/tests/baselines/reference/correctOrderOfPromiseMethod.types
+++ b/tests/baselines/reference/correctOrderOfPromiseMethod.types
@@ -30,9 +30,9 @@ async function countEverything(): Promise<number> {
 >resultB : B[]
 >await Promise.all([        providerA(),        providerB(),    ] as const) : [A[], B[]]
 >Promise.all([        providerA(),        providerB(),    ] as const) : Promise<[A[], B[]]>
->Promise.all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: readonly 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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>; }
+>all : { <TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: readonly T[]): Promise<(awaited T)[]>; }
 >[        providerA(),        providerB(),    ] as const : readonly [Promise<A[]>, Promise<B[]>]
 >[        providerA(),        providerB(),    ] : readonly [Promise<A[]>, Promise<B[]>]
 
diff --git a/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types b/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types
index bf9666f3082..9dd2a9f92ff 100644
--- a/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types
+++ b/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types
@@ -28,10 +28,10 @@ export let lazyCard = () => import('./Card').then(a => a.default);
 >lazyCard : () => Promise<(suit: import("tests/cases/compiler/Types").Suit, rank: import("tests/cases/compiler/Types").Rank) => { suit: import("tests/cases/compiler/Types").Suit; rank: import("tests/cases/compiler/Types").Rank; }>
 >() => import('./Card').then(a => a.default) : () => Promise<(suit: import("tests/cases/compiler/Types").Suit, rank: import("tests/cases/compiler/Types").Rank) => { suit: import("tests/cases/compiler/Types").Suit; rank: import("tests/cases/compiler/Types").Rank; }>
 >import('./Card').then(a => a.default) : Promise<(suit: import("tests/cases/compiler/Types").Suit, rank: import("tests/cases/compiler/Types").Rank) => { suit: import("tests/cases/compiler/Types").Suit; rank: import("tests/cases/compiler/Types").Rank; }>
->import('./Card').then : <TResult1 = typeof import("tests/cases/compiler/Card"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/compiler/Card")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>import('./Card').then : <TResult1 = typeof import("tests/cases/compiler/Card"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/compiler/Card")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >import('./Card') : Promise<typeof import("tests/cases/compiler/Card")>
 >'./Card' : "./Card"
->then : <TResult1 = typeof import("tests/cases/compiler/Card"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/compiler/Card")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/compiler/Card"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/compiler/Card")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >a => a.default : (a: typeof import("tests/cases/compiler/Card")) => (suit: import("tests/cases/compiler/Types").Suit, rank: import("tests/cases/compiler/Types").Rank) => { suit: import("tests/cases/compiler/Types").Suit; rank: import("tests/cases/compiler/Types").Rank; }
 >a : typeof import("tests/cases/compiler/Card")
 >a.default : (suit: import("tests/cases/compiler/Types").Suit, rank: import("tests/cases/compiler/Types").Rank) => { suit: import("tests/cases/compiler/Types").Suit; rank: import("tests/cases/compiler/Types").Rank; }
diff --git a/tests/baselines/reference/esModuleInteropImportCall.types b/tests/baselines/reference/esModuleInteropImportCall.types
index 59d1de30768..25d686a3baa 100644
--- a/tests/baselines/reference/esModuleInteropImportCall.types
+++ b/tests/baselines/reference/esModuleInteropImportCall.types
@@ -9,10 +9,10 @@ export = foo;
 === tests/cases/compiler/index.ts ===
 import("./foo").then(f => {
 >import("./foo").then(f => {    f.default;}) : Promise<void>
->import("./foo").then : <TResult1 = { default: () => void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>import("./foo").then : <TResult1 = { default: () => void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >import("./foo") : Promise<{ default: () => void; }>
 >"./foo" : "./foo"
->then : <TResult1 = { default: () => void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = { default: () => void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f => {    f.default;} : (f: { default: () => void; }) => void
 >f : { default: () => void; }
 
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.types b/tests/baselines/reference/exportDefaultAsyncFunction2.types
index 0e6ad89ccdf..aac8139a770 100644
--- a/tests/baselines/reference/exportDefaultAsyncFunction2.types
+++ b/tests/baselines/reference/exportDefaultAsyncFunction2.types
@@ -19,9 +19,9 @@ export default async(() => await(Promise.resolve(1)));
 >await(Promise.resolve(1)) : any
 >await : (...args: any[]) => any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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/forAwaitForUnion.types b/tests/baselines/reference/forAwaitForUnion.types
index 180197b26ea..182196ebbcb 100644
--- a/tests/baselines/reference/forAwaitForUnion.types
+++ b/tests/baselines/reference/forAwaitForUnion.types
@@ -4,7 +4,7 @@ async function f<T>(source: Iterable<T> | AsyncIterable<T>) {
 >source : Iterable<T> | AsyncIterable<T>
 
     for await (const x of source) {
->x : T
+>x : T | awaited T
 >source : Iterable<T> | AsyncIterable<T>
     }
 }
diff --git a/tests/baselines/reference/genericFunctionInference1.types b/tests/baselines/reference/genericFunctionInference1.types
index 1974fe17bea..45cbe87da17 100644
--- a/tests/baselines/reference/genericFunctionInference1.types
+++ b/tests/baselines/reference/genericFunctionInference1.types
@@ -835,16 +835,16 @@ const fn30: Fn = pipe(
 const promise = Promise.resolve(1);
 >promise : 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
 
 promise.then(
 >promise.then(    pipe(        x => x + 1,        x => x * 2,    ),) : Promise<number>
->promise.then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>promise.then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >promise : Promise<number>
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 
     pipe(
 >pipe(        x => x + 1,        x => x * 2,    ) : (x: number) => number
diff --git a/tests/baselines/reference/importCallExpression1ES2020.types b/tests/baselines/reference/importCallExpression1ES2020.types
index fd3564b2c14..c85b13c2d2b 100644
--- a/tests/baselines/reference/importCallExpression1ES2020.types
+++ b/tests/baselines/reference/importCallExpression1ES2020.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpression2ES2020.types b/tests/baselines/reference/importCallExpression2ES2020.types
index 80580e35d53..b59b0a558c3 100644
--- a/tests/baselines/reference/importCallExpression2ES2020.types
+++ b/tests/baselines/reference/importCallExpression2ES2020.types
@@ -14,9 +14,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/importCallExpression4ES2020.types b/tests/baselines/reference/importCallExpression4ES2020.types
index e7f75126c14..486ee14ecfd 100644
--- a/tests/baselines/reference/importCallExpression4ES2020.types
+++ b/tests/baselines/reference/importCallExpression4ES2020.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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
 >this : this
 >myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("tests/cases/conformance/dynamicImport/0")) => void
 >Zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionES5AMD.types b/tests/baselines/reference/importCallExpressionES5AMD.types
index ceb6a6fe299..c7ae81e3e07 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionES5CJS.types b/tests/baselines/reference/importCallExpressionES5CJS.types
index ceb6a6fe299..c7ae81e3e07 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionES5System.types b/tests/baselines/reference/importCallExpressionES5System.types
index ceb6a6fe299..c7ae81e3e07 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionES5UMD.types b/tests/baselines/reference/importCallExpressionES5UMD.types
index ceb6a6fe299..c7ae81e3e07 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionES6AMD.types b/tests/baselines/reference/importCallExpressionES6AMD.types
index ceb6a6fe299..c7ae81e3e07 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionES6CJS.types b/tests/baselines/reference/importCallExpressionES6CJS.types
index ceb6a6fe299..c7ae81e3e07 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionES6System.types b/tests/baselines/reference/importCallExpressionES6System.types
index ceb6a6fe299..c7ae81e3e07 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionES6UMD.types b/tests/baselines/reference/importCallExpressionES6UMD.types
index ceb6a6fe299..c7ae81e3e07 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionErrorInES2015.types b/tests/baselines/reference/importCallExpressionErrorInES2015.types
index f0a055e7a06..14c8e9f474a 100644
--- a/tests/baselines/reference/importCallExpressionErrorInES2015.types
+++ b/tests/baselines/reference/importCallExpressionErrorInES2015.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionInAMD1.types b/tests/baselines/reference/importCallExpressionInAMD1.types
index 6d270e686ed..68a828988de 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionInAMD2.types b/tests/baselines/reference/importCallExpressionInAMD2.types
index 875118acbac..c22c0462dc3 100644
--- a/tests/baselines/reference/importCallExpressionInAMD2.types
+++ b/tests/baselines/reference/importCallExpressionInAMD2.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/importCallExpressionInAMD4.types b/tests/baselines/reference/importCallExpressionInAMD4.types
index afedd6f4b81..9047c6ae5dd 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
 >this : this
 >myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("tests/cases/conformance/dynamicImport/0")) => void
 >Zero : typeof import("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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
 >this : this
 >myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("tests/cases/conformance/dynamicImport/0")) => void
 >Zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionInCJS1.types b/tests/baselines/reference/importCallExpressionInCJS1.types
index 6d270e686ed..68a828988de 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionInCJS3.types b/tests/baselines/reference/importCallExpressionInCJS3.types
index 875118acbac..c22c0462dc3 100644
--- a/tests/baselines/reference/importCallExpressionInCJS3.types
+++ b/tests/baselines/reference/importCallExpressionInCJS3.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/importCallExpressionInCJS5.types b/tests/baselines/reference/importCallExpressionInCJS5.types
index aea65c14070..f23b0074d7c 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
 >this : this
 >myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("tests/cases/conformance/dynamicImport/0")) => void
 >Zero : typeof import("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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
 >this : this
 >myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("tests/cases/conformance/dynamicImport/0")) => void
 >Zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionInSystem1.types b/tests/baselines/reference/importCallExpressionInSystem1.types
index 6d270e686ed..68a828988de 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionInSystem2.types b/tests/baselines/reference/importCallExpressionInSystem2.types
index 875118acbac..c22c0462dc3 100644
--- a/tests/baselines/reference/importCallExpressionInSystem2.types
+++ b/tests/baselines/reference/importCallExpressionInSystem2.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/importCallExpressionInSystem4.types b/tests/baselines/reference/importCallExpressionInSystem4.types
index afedd6f4b81..9047c6ae5dd 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
 >this : this
 >myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("tests/cases/conformance/dynamicImport/0")) => void
 >Zero : typeof import("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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
 >this : this
 >myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("tests/cases/conformance/dynamicImport/0")) => void
 >Zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionInUMD1.types b/tests/baselines/reference/importCallExpressionInUMD1.types
index 6d270e686ed..68a828988de 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof import("tests/cases/conformance/dynamicImport/0")) => string
 >zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionInUMD2.types b/tests/baselines/reference/importCallExpressionInUMD2.types
index 875118acbac..c22c0462dc3 100644
--- a/tests/baselines/reference/importCallExpressionInUMD2.types
+++ b/tests/baselines/reference/importCallExpressionInUMD2.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/importCallExpressionInUMD4.types b/tests/baselines/reference/importCallExpressionInUMD4.types
index afedd6f4b81..9047c6ae5dd 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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
 >this : this
 >myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("tests/cases/conformance/dynamicImport/0")) => void
 >Zero : typeof import("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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
 >this : this
 >myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("tests/cases/conformance/dynamicImport/0")) => void
 >Zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types
index ef8cdaec2fa..d55db9a3682 100644
--- a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types
+++ b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.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 import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule.then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
 >this : this
 >myModule : Promise<typeof import("tests/cases/conformance/dynamicImport/0")>
->then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = typeof import("tests/cases/conformance/dynamicImport/0"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/0")) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("tests/cases/conformance/dynamicImport/0")) => void
 >Zero : typeof import("tests/cases/conformance/dynamicImport/0")
 
diff --git a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
index b5f526adc8e..b5864754cc2 100644
--- a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
+++ b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
@@ -66,9 +66,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 6c452283446..45fe9ef6cc2 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/importCallExpressionSpecifierNotStringTypeError.types b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types
index 6378e7c582b..45def709454 100644
--- a/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types
+++ b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types
@@ -28,9 +28,9 @@ const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
 
 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/inferFromGenericFunctionReturnTypes3.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
index f9192dd11ba..a5259b88f62 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
@@ -7,9 +7,9 @@ function truePromise(): Promise<true> {
 
     return Promise.resolve(true);
 >Promise.resolve(true) : Promise<true>
->Promise.resolve : { <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>; }
 >true : true
 }
 
@@ -413,9 +413,9 @@ const f1: F = () => {
 
     return Promise.all([
 >Promise.all([        {            name: "David Gomes",            age: 23,            position: "GOALKEEPER",        }, {            name: "Cristiano Ronaldo",            age: 33,            position: "STRIKER",        }    ]) : Promise<[{ name: string; age: number; position: "GOALKEEPER"; }, { name: string; age: number; position: "STRIKER"; }]>
->Promise.all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: readonly 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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>; }
+>all : { <TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: readonly T[]): Promise<(awaited T)[]>; }
 >[        {            name: "David Gomes",            age: 23,            position: "GOALKEEPER",        }, {            name: "Cristiano Ronaldo",            age: 33,            position: "STRIKER",        }    ] : [{ name: string; age: number; position: "GOALKEEPER"; }, { name: string; age: number; position: "STRIKER"; }]
         {
 >{            name: "David Gomes",            age: 23,            position: "GOALKEEPER",        } : { name: string; age: number; position: "GOALKEEPER"; }
diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types
index fc2836e6dea..0ef33dda912 100644
--- a/tests/baselines/reference/inferenceLimit.types
+++ b/tests/baselines/reference/inferenceLimit.types
@@ -42,7 +42,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
@@ -52,7 +52,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
 
@@ -74,11 +74,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 = unknown[], TResult2 = never>(onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>Promise.all(result.map(populateItems))      .then : <TResult1 = unknown[], TResult2 = never>(onfulfilled?: (value: unknown[]) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Promise.all(result.map(populateItems)) : Promise<unknown[]>
->Promise.all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: readonly 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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>; }
+>all : { <TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [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: readonly [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: readonly [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: readonly [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: readonly [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: readonly [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: readonly T[]): Promise<(awaited T)[]>; }
 >result.map(populateItems) : Promise<unknown>[]
 >result.map : <U>(callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
 >result : MyModule.MyModel[]
@@ -86,7 +86,7 @@ export class BrokenClass {
 >populateItems : (order: any) => Promise<unknown>
 
       .then((orders: Array<MyModule.MyModel>) => {
->then : <TResult1 = unknown[], TResult2 = never>(onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = unknown[], TResult2 = never>(onfulfilled?: (value: unknown[]) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >(orders: Array<MyModule.MyModel>) => {        resolve(orders);      } : (orders: MyModule.MyModel[]) => void
 >orders : MyModule.MyModel[]
 >MyModule : any
diff --git a/tests/baselines/reference/instantiateContextualTypes.types b/tests/baselines/reference/instantiateContextualTypes.types
index b5317b6f756..021b6fe2732 100644
--- a/tests/baselines/reference/instantiateContextualTypes.types
+++ b/tests/baselines/reference/instantiateContextualTypes.types
@@ -340,12 +340,12 @@ class Interesting {
 
 		return Promise.resolve().then(() => {
 >Promise.resolve().then(() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'ELSE';		}) : Promise<DooDad>
->Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >Promise.resolve() : Promise<void>
->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>; }
->then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
+>then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'ELSE';		} : () => "SOMETHING" | "ELSE"
 
 			if (1 < 2) {
@@ -367,12 +367,12 @@ class Interesting {
 
 		return Promise.resolve().then(() => {
 >Promise.resolve().then(() => {			return 'ELSE';		}) : Promise<DooDad>
->Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >Promise.resolve() : Promise<void>
->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>; }
->then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
+>then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {			return 'ELSE';		} : () => "ELSE"
 
 			return 'ELSE';
@@ -386,12 +386,12 @@ class Interesting {
 
 		return Promise.resolve().then(() => {
 >Promise.resolve().then(() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'SOMETHING';		}) : Promise<DooDad>
->Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >Promise.resolve() : Promise<void>
->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>; }
->then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
+>then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'SOMETHING';		} : () => "SOMETHING"
 
 			if (1 < 2) {
diff --git a/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.types b/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.types
index 3fab5033c23..fb733482361 100644
--- a/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.types
+++ b/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.types
@@ -27,18 +27,18 @@ function returnAnyArray(arr) {
 var anyPromise = Promise.resolve(5);
 >anyPromise : Promise<any>
 >Promise.resolve(5) : Promise<number>
->Promise.resolve : { <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>; }
 >5 : 5
 
 /** @type {Promise<number>} */
 var numberPromise = Promise.resolve(5);
 >numberPromise : Promise<number>
 >Promise.resolve(5) : 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>; }
 >5 : 5
 
 /**
diff --git a/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.types b/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.types
index 82ff886f1ec..ba91dbb90b1 100644
--- a/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.types
+++ b/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.types
@@ -27,18 +27,18 @@ function returnNotAnyArray(arr) {
 var notAnyPromise = Promise.resolve(5);
 >notAnyPromise : Promise<any>
 >Promise.resolve(5) : Promise<number>
->Promise.resolve : { <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>; }
 >5 : 5
 
 /** @type {Promise<number>} */
 var numberPromise = Promise.resolve(5);
 >numberPromise : Promise<number>
 >Promise.resolve(5) : 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>; }
 >5 : 5
 
 /**
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
index c9a0476c2ad..3db392d286c 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
@@ -148,10 +148,10 @@ declare var console: any;
 
 out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
->out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >out() : Promise<unknown>
 >out : () => Promise<unknown>
->then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => 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 a695213a42c..c2773af516b 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
@@ -148,10 +148,10 @@ declare var console: any;
 
 out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
->out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >out() : Promise<unknown>
 >out : () => Promise<unknown>
->then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => 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 3e7c23fde87..aefc1cd5d60 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
@@ -148,10 +148,10 @@ declare var console: any;
 
 out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
->out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >out() : Promise<unknown>
 >out : () => Promise<unknown>
->then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => 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 dd468d33e6e..60574005493 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/optionalFunctionArgAssignability.types b/tests/baselines/reference/optionalFunctionArgAssignability.types
index a1975cc3645..b98228129db 100644
--- a/tests/baselines/reference/optionalFunctionArgAssignability.types
+++ b/tests/baselines/reference/optionalFunctionArgAssignability.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/optionalFunctionArgAssignability.ts ===
 interface Promise<T> {
     then<U>(onFulfill?: (value: T) => U, onReject?: (reason: any) => U): Promise<U>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(onFulfill?: (value: T) => U, onReject?: (reason: any) => U): Promise<U>; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(onFulfill?: (value: T) => U, onReject?: (reason: any) => U): Promise<U>; }
 >onFulfill : (value: T) => U
 >value : T
 >onReject : (reason: any) => U
diff --git a/tests/baselines/reference/promisePermutations.errors.txt b/tests/baselines/reference/promisePermutations.errors.txt
index 8b70977a0e5..3b2d937c7a8 100644
--- a/tests/baselines/reference/promisePermutations.errors.txt
+++ b/tests/baselines/reference/promisePermutations.errors.txt
@@ -124,7 +124,7 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2769: No overload m
     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
       Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
         The types of 'then' are incompatible between these types.
-          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'.
@@ -483,7 +483,7 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2769: No overload m
 !!! error TS2769:     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 !!! error TS2769:       Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
 !!! error TS2769:         The types of 'then' are incompatible between these types.
-!!! error TS2769:           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 TS2769:           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 TS2769:             Types of parameters 'onfulfilled' and 'success' are incompatible.
 !!! error TS2769:               Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2769:                 Type 'number' is not assignable to type 'string'.
diff --git a/tests/baselines/reference/promisePermutations.types b/tests/baselines/reference/promisePermutations.types
index 0dbe5f7ec0e..774f85bf684 100644
--- a/tests/baselines/reference/promisePermutations.types
+++ b/tests/baselines/reference/promisePermutations.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/promisePermutations.ts ===
 interface Promise<T> {
     then<U>(success?: (value: T) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >success : (value: T) => Promise<U>
 >value : T
 >error : (error: any) => Promise<U>
@@ -10,7 +10,7 @@ interface Promise<T> {
 >progress : any
 
     then<U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >success : (value: T) => Promise<U>
 >value : T
 >error : (error: any) => U
@@ -19,7 +19,7 @@ interface Promise<T> {
 >progress : any
 
     then<U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >success : (value: T) => U
 >value : T
 >error : (error: any) => Promise<U>
@@ -28,7 +28,7 @@ interface Promise<T> {
 >progress : any
 
     then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >success : (value: T) => U
 >value : T
 >error : (error: any) => U
@@ -272,9 +272,9 @@ var s1: Promise<number>;
 var s1a = s1.then(testFunction, testFunction, testFunction);
 >s1a : Promise<IPromise<number>>
 >s1.then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
@@ -282,9 +282,9 @@ var s1a = s1.then(testFunction, testFunction, testFunction);
 var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP);
 >s1b : Promise<number>
 >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise<number>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunctionP : () => Promise<number>
 >testFunctionP : () => Promise<number>
 >testFunctionP : () => Promise<number>
@@ -292,9 +292,9 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP);
 var s1c = s1.then(testFunctionP, testFunction, testFunction);
 >s1c : Promise<IPromise<number>>
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunctionP : () => Promise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
@@ -302,15 +302,15 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction);
 var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction);
 >s1d : Promise<IPromise<number>>
 >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then(testFunctionP, testFunction, testFunction).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s1.then(testFunctionP, testFunction, testFunction).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunctionP : () => Promise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
@@ -352,9 +352,9 @@ var s2: Promise<{ x: number; }>;
 var s2a = s2.then(testFunction2, testFunction2, testFunction2);
 >s2a : Promise<IPromise<{ x: number; }>>
 >s2.then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -362,9 +362,9 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2);
 var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P);
 >s2b : Promise<{ x: number; }>
 >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise<{ x: number; }>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2P : () => Promise<{ x: number; }>
@@ -372,9 +372,9 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P);
 var s2c = s2.then(testFunction2P, testFunction2, testFunction2);
 >s2c : Promise<IPromise<{ x: number; }>>
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -382,15 +382,15 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2);
 var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2);
 >s2d : Promise<IPromise<{ x: number; }>>
 >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then(testFunction2P, testFunction2, testFunction2).then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then(testFunction2P, testFunction2, testFunction2).then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
->then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -430,9 +430,9 @@ var s3: Promise<number>;
 var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 >s3a : Promise<IPromise<number>>
 >s3.then(testFunction3, testFunction3, testFunction3) : Promise<IPromise<number>>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
@@ -440,9 +440,9 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 >s3b : Promise<number>
 >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise<number>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3P : (x: number) => Promise<number>
@@ -450,9 +450,9 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
 >s3c : Promise<IPromise<number>>
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
@@ -460,15 +460,15 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
 var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3); // error
 >s3d : any
 >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : any
->s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
@@ -516,9 +516,9 @@ var s4: Promise<string>;
 var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 >s4a : any
 >s4.then(testFunction4, testFunction4, testFunction4) : any
->s4.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -526,9 +526,9 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error 
 >s4b : any
 >s4.then(testFunction4P, testFunction4P, testFunction4P) : any
->s4.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -536,9 +536,9 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error
 var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
 >s4c : any
 >s4.then(testFunction4P, testFunction4, testFunction4) : any
->s4.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -546,15 +546,15 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
 var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
 >s4d : Promise<IPromise<string>>
 >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
->s4.then(sIPromise, testFunction4P, testFunction4).then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then(sIPromise, testFunction4P, testFunction4).then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4.then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
->s4.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
->then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -594,9 +594,9 @@ var s5: Promise<string>;
 var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error
 >s5a : any
 >s5.then(testFunction5, testFunction5, testFunction5) : any
->s5.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -604,9 +604,9 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error
 var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error
 >s5b : any
 >s5.then(testFunction5P, testFunction5P, testFunction5P) : any
->s5.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
@@ -614,9 +614,9 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error
 var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error
 >s5c : any
 >s5.then(testFunction5P, testFunction5, testFunction5) : any
->s5.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -624,15 +624,15 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error
 var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise); // ok
 >s5d : Promise<IPromise<string>>
 >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s5.then(sPromise, sPromise, sPromise).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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then(sPromise, sPromise, sPromise).then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5.then(sPromise, sPromise, sPromise) : Promise<string>
->s5.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -672,9 +672,9 @@ var s6: Promise<string>;
 var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error
 >s6a : any
 >s6.then(testFunction6, testFunction6, testFunction6) : any
->s6.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -682,9 +682,9 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error
 var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error
 >s6b : any
 >s6.then(testFunction6P, testFunction6P, testFunction6P) : any
->s6.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
@@ -692,9 +692,9 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error
 var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error
 >s6c : any
 >s6.then(testFunction6P, testFunction6, testFunction6) : any
->s6.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -702,15 +702,15 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error
 var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise); // ok
 >s6d : Promise<IPromise<string>>
 >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s6.then(sPromise, sPromise, sPromise).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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then(sPromise, sPromise, sPromise).then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6.then(sPromise, sPromise, sPromise) : Promise<string>
->s6.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -836,9 +836,9 @@ var s8: Promise<number>;
 var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error
 >s8a : any
 >s8.then(testFunction8, testFunction8, testFunction8) : any
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -846,9 +846,9 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error
 var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error
 >s8b : any
 >s8.then(testFunction8P, testFunction8P, testFunction8P) : any
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
@@ -856,9 +856,9 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error
 var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error
 >s8c : any
 >s8.then(testFunction8P, testFunction8, testFunction8) : any
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -866,15 +866,15 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error
 var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise); // ok
 >s8d : Promise<IPromise<number>>
 >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
->s8.then(nIPromise, nIPromise, nIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s8.then(nIPromise, nIPromise, nIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s8.then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
@@ -944,9 +944,9 @@ var s9: Promise<number>;
 var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
 >s9a : any
 >s9.then(testFunction9, testFunction9, testFunction9) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -954,9 +954,9 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
 var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 >s9b : any
 >s9.then(testFunction9P, testFunction9P, testFunction9P) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
@@ -964,9 +964,9 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 >s9c : any
 >s9.then(testFunction9P, testFunction9, testFunction9) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -974,9 +974,9 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 >s9d : Promise<string>
 >s9.then(sPromise, sPromise, sPromise) : Promise<string>
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
@@ -984,9 +984,9 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
 >s9e : Promise<number>
 >s9.then(nPromise, nPromise, nPromise) : Promise<number>
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >nPromise : (x: any) => Promise<number>
 >nPromise : (x: any) => Promise<number>
 >nPromise : (x: any) => Promise<number>
@@ -994,9 +994,9 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok
 var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 >s9f : any
 >s9.then(testFunction, sIPromise, nIPromise) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction : () => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
 >nIPromise : (x: any) => IPromise<number>
@@ -1004,15 +1004,15 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 >s9g : Promise<IPromise<string>>
 >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s9.then(testFunction, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s9.then(testFunction, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s9.then(testFunction, nIPromise, sIPromise) : Promise<IPromise<number>>
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction : () => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -1092,9 +1092,9 @@ var s10 = testFunction10P(x => x);
 var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
 >s10a : Promise<IPromise<unknown>>
 >s10.then(testFunction10, testFunction10, testFunction10) : Promise<IPromise<unknown>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1102,9 +1102,9 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
 var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 >s10b : Promise<unknown>
 >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise<unknown>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
@@ -1112,9 +1112,9 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 >s10c : Promise<unknown>
 >s10.then(testFunction10P, testFunction10, testFunction10) : Promise<unknown>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1122,9 +1122,9 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 >s10d : Promise<string>
 >s10.then(sPromise, sPromise, sPromise) : Promise<string>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
@@ -1132,9 +1132,9 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
 >s10e : Promise<IPromise<number>>
 >s10.then(nIPromise, nPromise, nIPromise) : Promise<IPromise<number>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >nIPromise : (x: any) => IPromise<number>
 >nPromise : (x: any) => Promise<number>
 >nIPromise : (x: any) => IPromise<number>
@@ -1142,9 +1142,9 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
 var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 >s10f : any
 >s10.then(testFunctionP, sIPromise, nIPromise) : any
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunctionP : () => Promise<number>
 >sIPromise : (x: any) => IPromise<string>
 >nIPromise : (x: any) => IPromise<number>
@@ -1152,15 +1152,15 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 >s10g : Promise<IPromise<string>>
 >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s10.then(testFunctionP, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then(testFunctionP, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10.then(testFunctionP, nIPromise, sIPromise) : Promise<IPromise<number>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunctionP : () => Promise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -1184,9 +1184,9 @@ var s11: Promise<number>;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 >s11a : any
 >s11.then(testFunction11, testFunction11, testFunction11) : any
->s11.then : { <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>; }
+>s11.then : { <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>; }
 >s11 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -1194,9 +1194,9 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
 >s11b : any
 >s11.then(testFunction11P, testFunction11P, testFunction11P) : any
->s11.then : { <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>; }
+>s11.then : { <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>; }
 >s11 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
@@ -1204,9 +1204,9 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
 var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
 >s11c : any
 >s11.then(testFunction11P, testFunction11, testFunction11) : any
->s11.then : { <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>; }
+>s11.then : { <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>; }
 >s11 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
diff --git a/tests/baselines/reference/promisePermutations2.errors.txt b/tests/baselines/reference/promisePermutations2.errors.txt
index bc676c9dd5e..2a79807e312 100644
--- a/tests/baselines/reference/promisePermutations2.errors.txt
+++ b/tests/baselines/reference/promisePermutations2.errors.txt
@@ -82,7 +82,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>'.
   Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
     The types of 'then' are incompatible between these types.
-      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'.
@@ -378,7 +378,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:   Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
 !!! error TS2345:     The types of 'then' are incompatible between these types.
-!!! 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/promisePermutations2.types b/tests/baselines/reference/promisePermutations2.types
index 957b548a284..082751934d2 100644
--- a/tests/baselines/reference/promisePermutations2.types
+++ b/tests/baselines/reference/promisePermutations2.types
@@ -3,7 +3,7 @@
 
 interface Promise<T> {
     then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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, error?: (error: any) => U, progress?: (progress: any) => void): 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, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >success : (value: T) => U
 >value : T
 >error : (error: any) => U
@@ -247,9 +247,9 @@ var s1: Promise<number>;
 var s1a = s1.then(testFunction, testFunction, testFunction);
 >s1a : Promise<IPromise<number>>
 >s1.then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
@@ -257,9 +257,9 @@ var s1a = s1.then(testFunction, testFunction, testFunction);
 var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP);
 >s1b : Promise<Promise<number>>
 >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise<Promise<number>>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunctionP : () => Promise<number>
 >testFunctionP : () => Promise<number>
 >testFunctionP : () => Promise<number>
@@ -267,9 +267,9 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP);
 var s1c = s1.then(testFunctionP, testFunction, testFunction);
 >s1c : Promise<IPromise<number>>
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunctionP : () => Promise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
@@ -277,15 +277,15 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction);
 var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction);
 >s1d : Promise<IPromise<number>>
 >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then(testFunctionP, testFunction, testFunction).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s1.then(testFunctionP, testFunction, testFunction).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunctionP : () => Promise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
@@ -327,9 +327,9 @@ var s2: Promise<{ x: number; }>;
 var s2a = s2.then(testFunction2, testFunction2, testFunction2);
 >s2a : Promise<IPromise<{ x: number; }>>
 >s2.then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -337,9 +337,9 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2);
 var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P);
 >s2b : Promise<Promise<{ x: number; }>>
 >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise<Promise<{ x: number; }>>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2P : () => Promise<{ x: number; }>
@@ -347,9 +347,9 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P);
 var s2c = s2.then(testFunction2P, testFunction2, testFunction2);
 >s2c : Promise<IPromise<{ x: number; }>>
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -357,15 +357,15 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2);
 var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2);
 >s2d : Promise<IPromise<{ x: number; }>>
 >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then(testFunction2P, testFunction2, testFunction2).then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then(testFunction2P, testFunction2, testFunction2).then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
->then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -405,9 +405,9 @@ var s3: Promise<number>;
 var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 >s3a : Promise<IPromise<number>>
 >s3.then(testFunction3, testFunction3, testFunction3) : Promise<IPromise<number>>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
@@ -415,9 +415,9 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 >s3b : Promise<Promise<number>>
 >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise<Promise<number>>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3P : (x: number) => Promise<number>
@@ -425,9 +425,9 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
 >s3c : Promise<IPromise<number>>
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
@@ -435,15 +435,15 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
 var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3); // Should error
 >s3d : any
 >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : any
->s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
@@ -491,9 +491,9 @@ var s4: Promise<string>;
 var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 >s4a : any
 >s4.then(testFunction4, testFunction4, testFunction4) : any
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -501,9 +501,9 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error 
 >s4b : any
 >s4.then(testFunction4P, testFunction4P, testFunction4P) : any
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -511,9 +511,9 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error
 var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
 >s4c : any
 >s4.then(testFunction4P, testFunction4, testFunction4) : any
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -521,15 +521,15 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
 var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
 >s4d : Promise<IPromise<string>>
 >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
->s4.then(sIPromise, testFunction4P, testFunction4).then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then(sIPromise, testFunction4P, testFunction4).then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4.then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
->then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -569,9 +569,9 @@ var s5: Promise<string>;
 var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error
 >s5a : any
 >s5.then(testFunction5, testFunction5, testFunction5) : any
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -579,9 +579,9 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error
 var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error
 >s5b : any
 >s5.then(testFunction5P, testFunction5P, testFunction5P) : any
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
@@ -589,9 +589,9 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error
 var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error
 >s5c : any
 >s5.then(testFunction5P, testFunction5, testFunction5) : any
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -599,15 +599,15 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error
 var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise); // ok
 >s5d : Promise<IPromise<string>>
 >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s5.then(sPromise, sPromise, sPromise).then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: Promise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then(sPromise, sPromise, sPromise).then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5.then(sPromise, sPromise, sPromise) : Promise<Promise<string>>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
->then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: Promise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -647,9 +647,9 @@ var s6: Promise<string>;
 var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error
 >s6a : any
 >s6.then(testFunction6, testFunction6, testFunction6) : any
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -657,9 +657,9 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error
 var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error
 >s6b : any
 >s6.then(testFunction6P, testFunction6P, testFunction6P) : any
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
@@ -667,9 +667,9 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error
 var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error
 >s6c : any
 >s6.then(testFunction6P, testFunction6, testFunction6) : any
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -677,15 +677,15 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error
 var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise); // ok
 >s6d : Promise<IPromise<string>>
 >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s6.then(sPromise, sPromise, sPromise).then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: Promise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then(sPromise, sPromise, sPromise).then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6.then(sPromise, sPromise, sPromise) : Promise<Promise<string>>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
->then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: Promise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -811,9 +811,9 @@ var s8: Promise<number>;
 var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error
 >s8a : any
 >s8.then(testFunction8, testFunction8, testFunction8) : any
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -821,9 +821,9 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error
 var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error
 >s8b : any
 >s8.then(testFunction8P, testFunction8P, testFunction8P) : any
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
@@ -831,9 +831,9 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error
 var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error
 >s8c : any
 >s8.then(testFunction8P, testFunction8, testFunction8) : any
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -841,15 +841,15 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error
 var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise); // ok
 >s8d : Promise<IPromise<number>>
 >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
->s8.then(nIPromise, nIPromise, nIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s8.then(nIPromise, nIPromise, nIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s8.then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
@@ -919,9 +919,9 @@ var s9: Promise<number>;
 var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
 >s9a : any
 >s9.then(testFunction9, testFunction9, testFunction9) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -929,9 +929,9 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
 var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 >s9b : any
 >s9.then(testFunction9P, testFunction9P, testFunction9P) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
@@ -939,9 +939,9 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 >s9c : any
 >s9.then(testFunction9P, testFunction9, testFunction9) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -949,9 +949,9 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 >s9d : Promise<Promise<string>>
 >s9.then(sPromise, sPromise, sPromise) : Promise<Promise<string>>
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
@@ -959,9 +959,9 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
 >s9e : Promise<Promise<number>>
 >s9.then(nPromise, nPromise, nPromise) : Promise<Promise<number>>
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >nPromise : (x: any) => Promise<number>
 >nPromise : (x: any) => Promise<number>
 >nPromise : (x: any) => Promise<number>
@@ -969,9 +969,9 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok
 var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 >s9f : any
 >s9.then(testFunction, sIPromise, nIPromise) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction : () => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
 >nIPromise : (x: any) => IPromise<number>
@@ -979,15 +979,15 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 >s9g : Promise<IPromise<string>>
 >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s9.then(testFunction, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s9.then(testFunction, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s9.then(testFunction, nIPromise, sIPromise) : Promise<IPromise<number>>
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction : () => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -1067,9 +1067,9 @@ var s10 = testFunction10P(x => x);
 var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
 >s10a : Promise<IPromise<unknown>>
 >s10.then(testFunction10, testFunction10, testFunction10) : Promise<IPromise<unknown>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1077,9 +1077,9 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
 var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 >s10b : Promise<Promise<unknown>>
 >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise<Promise<unknown>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
@@ -1087,9 +1087,9 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 >s10c : Promise<IPromise<unknown>>
 >s10.then(testFunction10P, testFunction10, testFunction10) : Promise<IPromise<unknown>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1097,9 +1097,9 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 >s10d : Promise<Promise<string>>
 >s10.then(sPromise, sPromise, sPromise) : Promise<Promise<string>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
@@ -1107,9 +1107,9 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
 >s10e : Promise<IPromise<number>>
 >s10.then(nIPromise, nPromise, nIPromise) : Promise<IPromise<number>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >nIPromise : (x: any) => IPromise<number>
 >nPromise : (x: any) => Promise<number>
 >nIPromise : (x: any) => IPromise<number>
@@ -1117,9 +1117,9 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
 var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 >s10f : any
 >s10.then(testFunctionP, sIPromise, nIPromise) : any
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunctionP : () => Promise<number>
 >sIPromise : (x: any) => IPromise<string>
 >nIPromise : (x: any) => IPromise<number>
@@ -1127,15 +1127,15 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 >s10g : Promise<IPromise<string>>
 >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s10.then(testFunctionP, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then(testFunctionP, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10.then(testFunctionP, nIPromise, sIPromise) : Promise<IPromise<number>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunctionP : () => Promise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -1159,9 +1159,9 @@ var s11: Promise<number>;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 >s11a : any
 >s11.then(testFunction11, testFunction11, testFunction11) : any
->s11.then : { <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>; }
+>s11.then : { <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>; }
 >s11 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -1169,9 +1169,9 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
 >s11b : any
 >s11.then(testFunction11P, testFunction11P, testFunction11P) : any
->s11.then : { <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>; }
+>s11.then : { <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>; }
 >s11 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
@@ -1179,9 +1179,9 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
 var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
 >s11c : any
 >s11.then(testFunction11P, testFunction11, testFunction11) : any
->s11.then : { <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>; }
+>s11.then : { <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>; }
 >s11 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
diff --git a/tests/baselines/reference/promisePermutations3.errors.txt b/tests/baselines/reference/promisePermutations3.errors.txt
index 7467009abce..735203e307f 100644
--- a/tests/baselines/reference/promisePermutations3.errors.txt
+++ b/tests/baselines/reference/promisePermutations3.errors.txt
@@ -103,7 +103,7 @@ tests/cases/compiler/promisePermutations3.ts(159,21): error TS2769: No overload
     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
       Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
         The types of 'then' are incompatible between these types.
-          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'.
@@ -431,7 +431,7 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2769:     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 !!! error TS2769:       Call signature return types 'Promise<number>' and 'IPromise<string>' are incompatible.
 !!! error TS2769:         The types of 'then' are incompatible between these types.
-!!! error TS2769:           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 TS2769:           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 TS2769:             Types of parameters 'onfulfilled' and 'success' are incompatible.
 !!! error TS2769:               Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2769:                 Type 'number' is not assignable to type 'string'.
diff --git a/tests/baselines/reference/promisePermutations3.types b/tests/baselines/reference/promisePermutations3.types
index a643b89b23b..ab4b355c40e 100644
--- a/tests/baselines/reference/promisePermutations3.types
+++ b/tests/baselines/reference/promisePermutations3.types
@@ -3,7 +3,7 @@
 
 interface Promise<T> {
     then<U>(success?: (value: T) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >success : (value: T) => Promise<U>
 >value : T
 >error : (error: any) => Promise<U>
@@ -12,7 +12,7 @@ interface Promise<T> {
 >progress : any
 
     then<U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >success : (value: T) => Promise<U>
 >value : T
 >error : (error: any) => U
@@ -21,7 +21,7 @@ interface Promise<T> {
 >progress : any
 
     then<U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >success : (value: T) => U
 >value : T
 >error : (error: any) => Promise<U>
@@ -30,7 +30,7 @@ interface Promise<T> {
 >progress : any
 
     then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >success : (value: T) => U
 >value : T
 >error : (error: any) => U
@@ -247,9 +247,9 @@ var s1: Promise<number>;
 var s1a = s1.then(testFunction, testFunction, testFunction);
 >s1a : Promise<IPromise<number>>
 >s1.then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
@@ -257,9 +257,9 @@ var s1a = s1.then(testFunction, testFunction, testFunction);
 var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP);
 >s1b : Promise<number>
 >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise<number>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunctionP : () => Promise<number>
 >testFunctionP : () => Promise<number>
 >testFunctionP : () => Promise<number>
@@ -267,9 +267,9 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP);
 var s1c = s1.then(testFunctionP, testFunction, testFunction);
 >s1c : Promise<IPromise<number>>
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunctionP : () => Promise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
@@ -277,15 +277,15 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction);
 var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction);
 >s1d : Promise<IPromise<number>>
 >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then(testFunctionP, testFunction, testFunction).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s1.then(testFunctionP, testFunction, testFunction).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
->s1.then : { <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>; }
+>s1.then : { <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>; }
 >s1 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunctionP : () => Promise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
@@ -327,9 +327,9 @@ var s2: Promise<{ x: number; }>;
 var s2a = s2.then(testFunction2, testFunction2, testFunction2);
 >s2a : Promise<IPromise<{ x: number; }>>
 >s2.then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -337,9 +337,9 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2);
 var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P);
 >s2b : Promise<{ x: number; }>
 >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise<{ x: number; }>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2P : () => Promise<{ x: number; }>
@@ -347,9 +347,9 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P);
 var s2c = s2.then(testFunction2P, testFunction2, testFunction2);
 >s2c : Promise<IPromise<{ x: number; }>>
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -357,15 +357,15 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2);
 var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2);
 >s2d : Promise<IPromise<{ x: number; }>>
 >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then(testFunction2P, testFunction2, testFunction2).then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then(testFunction2P, testFunction2, testFunction2).then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
->s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s2 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
->then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -405,9 +405,9 @@ var s3: Promise<number>;
 var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 >s3a : Promise<IPromise<number>>
 >s3.then(testFunction3, testFunction3, testFunction3) : Promise<IPromise<number>>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
@@ -415,9 +415,9 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 >s3b : Promise<number>
 >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise<number>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3P : (x: number) => Promise<number>
@@ -425,9 +425,9 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
 >s3c : Promise<IPromise<number>>
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
@@ -435,15 +435,15 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
 var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3);
 >s3d : any
 >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : any
->s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
->s3.then : { <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>; }
+>s3.then : { <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>; }
 >s3 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
@@ -491,9 +491,9 @@ var s4: Promise<string>;
 var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 >s4a : any
 >s4.then(testFunction4, testFunction4, testFunction4) : any
->s4.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -501,9 +501,9 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error 
 >s4b : any
 >s4.then(testFunction4P, testFunction4P, testFunction4P) : any
->s4.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -511,9 +511,9 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error
 var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
 >s4c : any
 >s4.then(testFunction4P, testFunction4, testFunction4) : any
->s4.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -521,15 +521,15 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
 var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
 >s4d : Promise<IPromise<string>>
 >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
->s4.then(sIPromise, testFunction4P, testFunction4).then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then(sIPromise, testFunction4P, testFunction4).then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4.then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
->s4.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s4 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
->then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -569,9 +569,9 @@ var s5: Promise<string>;
 var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error
 >s5a : any
 >s5.then(testFunction5, testFunction5, testFunction5) : any
->s5.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -579,9 +579,9 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error
 var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error
 >s5b : any
 >s5.then(testFunction5P, testFunction5P, testFunction5P) : any
->s5.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
@@ -589,9 +589,9 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error
 var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error
 >s5c : any
 >s5.then(testFunction5P, testFunction5, testFunction5) : any
->s5.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -599,15 +599,15 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error
 var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise); // ok
 >s5d : Promise<IPromise<string>>
 >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s5.then(sPromise, sPromise, sPromise).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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then(sPromise, sPromise, sPromise).then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5.then(sPromise, sPromise, sPromise) : Promise<string>
->s5.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s5 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -647,9 +647,9 @@ var s6: Promise<string>;
 var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error
 >s6a : any
 >s6.then(testFunction6, testFunction6, testFunction6) : any
->s6.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -657,9 +657,9 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error
 var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error
 >s6b : any
 >s6.then(testFunction6P, testFunction6P, testFunction6P) : any
->s6.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
@@ -667,9 +667,9 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error
 var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error
 >s6c : any
 >s6.then(testFunction6P, testFunction6, testFunction6) : any
->s6.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -677,15 +677,15 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error
 var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise); // ok
 >s6d : Promise<IPromise<string>>
 >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s6.then(sPromise, sPromise, sPromise).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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then(sPromise, sPromise, sPromise).then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6.then(sPromise, sPromise, sPromise) : Promise<string>
->s6.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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s6 : Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
->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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): 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>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -811,9 +811,9 @@ var s8: Promise<number>;
 var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error
 >s8a : any
 >s8.then(testFunction8, testFunction8, testFunction8) : any
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -821,9 +821,9 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error
 var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error
 >s8b : any
 >s8.then(testFunction8P, testFunction8P, testFunction8P) : any
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
@@ -831,9 +831,9 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error
 var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error
 >s8c : any
 >s8.then(testFunction8P, testFunction8, testFunction8) : any
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -841,15 +841,15 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error
 var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise); // ok
 >s8d : Promise<IPromise<number>>
 >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
->s8.then(nIPromise, nIPromise, nIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s8.then(nIPromise, nIPromise, nIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s8.then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
->s8.then : { <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>; }
+>s8.then : { <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>; }
 >s8 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
@@ -919,9 +919,9 @@ var s9: Promise<number>;
 var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
 >s9a : any
 >s9.then(testFunction9, testFunction9, testFunction9) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -929,9 +929,9 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
 var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 >s9b : any
 >s9.then(testFunction9P, testFunction9P, testFunction9P) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
@@ -939,9 +939,9 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 >s9c : any
 >s9.then(testFunction9P, testFunction9, testFunction9) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -949,9 +949,9 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 >s9d : Promise<string>
 >s9.then(sPromise, sPromise, sPromise) : Promise<string>
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
@@ -959,9 +959,9 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
 >s9e : Promise<number>
 >s9.then(nPromise, nPromise, nPromise) : Promise<number>
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >nPromise : (x: any) => Promise<number>
 >nPromise : (x: any) => Promise<number>
 >nPromise : (x: any) => Promise<number>
@@ -969,9 +969,9 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok
 var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 >s9f : any
 >s9.then(testFunction, sIPromise, nIPromise) : any
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction : () => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
 >nIPromise : (x: any) => IPromise<number>
@@ -979,15 +979,15 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 >s9g : Promise<IPromise<string>>
 >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s9.then(testFunction, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s9.then(testFunction, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s9.then(testFunction, nIPromise, sIPromise) : Promise<IPromise<number>>
->s9.then : { <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>; }
+>s9.then : { <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>; }
 >s9 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction : () => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -1067,9 +1067,9 @@ var s10 = testFunction10P(x => x);
 var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
 >s10a : Promise<IPromise<unknown>>
 >s10.then(testFunction10, testFunction10, testFunction10) : Promise<IPromise<unknown>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1077,9 +1077,9 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
 var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 >s10b : Promise<unknown>
 >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise<unknown>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
@@ -1087,9 +1087,9 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 >s10c : Promise<unknown>
 >s10.then(testFunction10P, testFunction10, testFunction10) : Promise<unknown>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1097,9 +1097,9 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 >s10d : Promise<string>
 >s10.then(sPromise, sPromise, sPromise) : Promise<string>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
@@ -1107,9 +1107,9 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
 >s10e : Promise<IPromise<number>>
 >s10.then(nIPromise, nPromise, nIPromise) : Promise<IPromise<number>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >nIPromise : (x: any) => IPromise<number>
 >nPromise : (x: any) => Promise<number>
 >nIPromise : (x: any) => IPromise<number>
@@ -1117,9 +1117,9 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
 var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 >s10f : any
 >s10.then(testFunctionP, sIPromise, nIPromise) : any
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunctionP : () => Promise<number>
 >sIPromise : (x: any) => IPromise<string>
 >nIPromise : (x: any) => IPromise<number>
@@ -1127,15 +1127,15 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 >s10g : Promise<IPromise<string>>
 >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
->s10.then(testFunctionP, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then(testFunctionP, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10.then(testFunctionP, nIPromise, sIPromise) : Promise<IPromise<number>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >s10 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >testFunctionP : () => Promise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
+>then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
 >sPromise : (x: any) => Promise<string>
 >sIPromise : (x: any) => IPromise<string>
 >sIPromise : (x: any) => IPromise<string>
@@ -1159,9 +1159,9 @@ var s11: Promise<number>;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 >s11a : any
 >s11.then(testFunction11, testFunction11, testFunction11) : any
->s11.then : { <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>; }
+>s11.then : { <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>; }
 >s11 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -1169,9 +1169,9 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
 >s11b : any
 >s11.then(testFunction11P, testFunction11P, testFunction11P) : any
->s11.then : { <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>; }
+>s11.then : { <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>; }
 >s11 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
@@ -1179,9 +1179,9 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
 var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
 >s11c : any
 >s11.then(testFunction11P, testFunction11, testFunction11) : any
->s11.then : { <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>; }
+>s11.then : { <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>; }
 >s11 : Promise<number>
->then : { <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>; }
+>then : { <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>; }
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
diff --git a/tests/baselines/reference/promiseTest.types b/tests/baselines/reference/promiseTest.types
index 3d250c11c1f..f122fd3dac0 100644
--- a/tests/baselines/reference/promiseTest.types
+++ b/tests/baselines/reference/promiseTest.types
@@ -1,12 +1,12 @@
 === tests/cases/compiler/promiseTest.ts ===
 interface Promise<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>; }
 >success : (value: T) => Promise<A>
 >value : T
 
     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>; }
 >success : (value: T) => B
 >value : T
 
@@ -21,9 +21,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 dd20fb656ea..0e49d459d4c 100644
--- a/tests/baselines/reference/promiseType.types
+++ b/tests/baselines/reference/promiseType.types
@@ -104,9 +104,9 @@ async function F() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -169,9 +169,9 @@ async function I() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -182,231 +182,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -414,9 +414,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
@@ -424,9 +424,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
@@ -434,9 +434,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
@@ -444,18 +444,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
@@ -463,55 +463,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -519,9 +519,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
@@ -529,9 +529,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
@@ -539,9 +539,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
@@ -549,18 +549,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
@@ -568,37 +568,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -606,9 +606,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
@@ -616,9 +616,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
@@ -627,9 +627,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
@@ -638,9 +638,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
@@ -649,9 +649,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
@@ -660,9 +660,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
@@ -670,9 +670,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
@@ -681,39 +681,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -721,9 +721,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
@@ -731,9 +731,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
@@ -742,9 +742,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
@@ -753,9 +753,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
@@ -764,9 +764,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
@@ -775,9 +775,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
@@ -785,9 +785,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
@@ -796,39 +796,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -836,9 +836,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
@@ -846,9 +846,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
@@ -857,9 +857,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
@@ -868,9 +868,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
@@ -879,9 +879,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
@@ -890,9 +890,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
@@ -900,9 +900,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
@@ -911,39 +911,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -951,9 +951,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
@@ -961,9 +961,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
@@ -972,9 +972,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
@@ -983,9 +983,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
@@ -994,9 +994,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
@@ -1005,9 +1005,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
@@ -1015,9 +1015,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
@@ -1026,57 +1026,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -1084,9 +1084,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
@@ -1094,9 +1094,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
@@ -1104,9 +1104,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
@@ -1114,18 +1114,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
@@ -1133,37 +1133,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -1171,9 +1171,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
@@ -1181,9 +1181,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
@@ -1192,9 +1192,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
@@ -1203,9 +1203,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
@@ -1214,9 +1214,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
@@ -1225,9 +1225,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
@@ -1235,9 +1235,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
@@ -1246,72 +1246,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -1319,14 +1319,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
@@ -1334,14 +1334,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
@@ -1349,14 +1349,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
@@ -1364,28 +1364,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
@@ -1393,80 +1393,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1474,14 +1474,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1489,14 +1489,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => undefined : () => any
 >undefined : undefined
@@ -1504,14 +1504,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => null : () => any
 >null : null
@@ -1519,28 +1519,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1548,38 +1548,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 ada81bfb496..00000000000
--- a/tests/baselines/reference/promiseTypeInference.errors.txt
+++ /dev/null
@@ -1,38 +0,0 @@
-tests/cases/compiler/promiseTypeInference.ts(10,39): error TS2769: No overload matches this call.
-  Overload 1 of 2, '(success?: (value: string) => Promise<unknown>): Promise<unknown>', gave the following error.
-    Property 'catch' is missing in type 'IPromise<number>' but required in type 'Promise<unknown>'.
-  Overload 2 of 2, '(onfulfilled?: (value: string) => number | PromiseLike<number>, onrejected?: (reason: any) => PromiseLike<never>): Promise<number>', gave the following error.
-    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.
-          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 TS2769: No overload matches this call.
-!!! error TS2769:   Overload 1 of 2, '(success?: (value: string) => Promise<unknown>): Promise<unknown>', gave the following error.
-!!! error TS2769:     Property 'catch' is missing in type 'IPromise<number>' but required in type 'Promise<unknown>'.
-!!! error TS2769:   Overload 2 of 2, '(onfulfilled?: (value: string) => number | PromiseLike<number>, onrejected?: (reason: any) => PromiseLike<never>): Promise<number>', gave the following error.
-!!! error TS2769:     Type 'IPromise<number>' is not assignable to type 'number | PromiseLike<number>'.
-!!! error TS2769:       Type 'IPromise<number>' is not assignable to type 'PromiseLike<number>'.
-!!! error TS2769:         Types of property 'then' are incompatible.
-!!! error TS2769:           Types of parameters 'success' and 'onfulfilled' are incompatible.
-!!! error TS2769:             Type 'TResult1 | PromiseLike<TResult1>' is not assignable to type 'IPromise<TResult1 | TResult2>'.
-!!! error TS2769:               Type 'TResult1' is not assignable to type 'IPromise<TResult1 | TResult2>'.
-!!! related TS2728 /.ts/lib.es5.d.ts:1430:5: 'catch' is declared here.
-!!! related TS6502 tests/cases/compiler/promiseTypeInference.ts:2:23: The expected type comes from the return type of this signature.
-!!! related TS6502 /.ts/lib.es5.d.ts:1423:57: The expected type comes from the return type of this signature.
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/promiseTypeInference.js b/tests/baselines/reference/promiseTypeInference.js
index 6faf131438a..fad9d4377be 100644
--- a/tests/baselines/reference/promiseTypeInference.js
+++ b/tests/baselines/reference/promiseTypeInference.js
@@ -1,11 +1,11 @@
 //// [promiseTypeInference.ts]
-declare class Promise<T> {
-    then<U>(success?: (value: T) => Promise<U>): Promise<U>;
+declare class CPromise<T> {
+    then<U>(success?: (value: T) => CPromise<U>): CPromise<U>;
 }
 interface IPromise<T> {
     then<U>(success?: (value: T) => IPromise<U>): IPromise<U>;
 }
-declare function load(name: string): Promise<string>;
+declare function load(name: string): CPromise<string>;
 declare function convert(s: string): IPromise<number>;
 
 var $$x = load("something").then(s => convert(s));
diff --git a/tests/baselines/reference/promiseTypeInference.symbols b/tests/baselines/reference/promiseTypeInference.symbols
index ae87c8a82b5..b7f746a4362 100644
--- a/tests/baselines/reference/promiseTypeInference.symbols
+++ b/tests/baselines/reference/promiseTypeInference.symbols
@@ -1,17 +1,17 @@
 === tests/cases/compiler/promiseTypeInference.ts ===
-declare class Promise<T> {
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 0))
->T : Symbol(T, Decl(lib.es5.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 22))
+declare class CPromise<T> {
+>CPromise : Symbol(CPromise, Decl(promiseTypeInference.ts, 0, 0))
+>T : Symbol(T, Decl(promiseTypeInference.ts, 0, 23))
 
-    then<U>(success?: (value: T) => Promise<U>): Promise<U>;
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 26))
+    then<U>(success?: (value: T) => CPromise<U>): CPromise<U>;
+>then : Symbol(CPromise.then, Decl(promiseTypeInference.ts, 0, 27))
 >U : Symbol(U, Decl(promiseTypeInference.ts, 1, 9))
 >success : Symbol(success, Decl(promiseTypeInference.ts, 1, 12))
 >value : Symbol(value, Decl(promiseTypeInference.ts, 1, 23))
->T : Symbol(T, Decl(lib.es5.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 22))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 0))
+>T : Symbol(T, Decl(promiseTypeInference.ts, 0, 23))
+>CPromise : Symbol(CPromise, Decl(promiseTypeInference.ts, 0, 0))
 >U : Symbol(U, Decl(promiseTypeInference.ts, 1, 9))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 0))
+>CPromise : Symbol(CPromise, Decl(promiseTypeInference.ts, 0, 0))
 >U : Symbol(U, Decl(promiseTypeInference.ts, 1, 9))
 }
 interface IPromise<T> {
@@ -29,22 +29,22 @@ interface IPromise<T> {
 >IPromise : Symbol(IPromise, Decl(promiseTypeInference.ts, 2, 1))
 >U : Symbol(U, Decl(promiseTypeInference.ts, 4, 9))
 }
-declare function load(name: string): Promise<string>;
+declare function load(name: string): CPromise<string>;
 >load : Symbol(load, Decl(promiseTypeInference.ts, 5, 1))
 >name : Symbol(name, Decl(promiseTypeInference.ts, 6, 22))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 0))
+>CPromise : Symbol(CPromise, Decl(promiseTypeInference.ts, 0, 0))
 
 declare function convert(s: string): IPromise<number>;
->convert : Symbol(convert, Decl(promiseTypeInference.ts, 6, 53))
+>convert : Symbol(convert, Decl(promiseTypeInference.ts, 6, 54))
 >s : Symbol(s, Decl(promiseTypeInference.ts, 7, 25))
 >IPromise : Symbol(IPromise, Decl(promiseTypeInference.ts, 2, 1))
 
 var $$x = load("something").then(s => convert(s));
 >$$x : Symbol($$x, Decl(promiseTypeInference.ts, 9, 3))
->load("something").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 26))
+>load("something").then : Symbol(CPromise.then, Decl(promiseTypeInference.ts, 0, 27))
 >load : Symbol(load, Decl(promiseTypeInference.ts, 5, 1))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 26))
+>then : Symbol(CPromise.then, Decl(promiseTypeInference.ts, 0, 27))
 >s : Symbol(s, Decl(promiseTypeInference.ts, 9, 33))
->convert : Symbol(convert, Decl(promiseTypeInference.ts, 6, 53))
+>convert : Symbol(convert, Decl(promiseTypeInference.ts, 6, 54))
 >s : Symbol(s, Decl(promiseTypeInference.ts, 9, 33))
 
diff --git a/tests/baselines/reference/promiseTypeInference.types b/tests/baselines/reference/promiseTypeInference.types
index 36b3bdadd28..2484e9b97d2 100644
--- a/tests/baselines/reference/promiseTypeInference.types
+++ b/tests/baselines/reference/promiseTypeInference.types
@@ -1,10 +1,10 @@
 === tests/cases/compiler/promiseTypeInference.ts ===
-declare class Promise<T> {
->Promise : Promise<T>
+declare class CPromise<T> {
+>CPromise : CPromise<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>; }
->success : (value: T) => Promise<U>
+    then<U>(success?: (value: T) => CPromise<U>): CPromise<U>;
+>then : <U>(success?: (value: T) => CPromise<U>) => CPromise<U>
+>success : (value: T) => CPromise<U>
 >value : T
 }
 interface IPromise<T> {
@@ -13,8 +13,8 @@ interface IPromise<T> {
 >success : (value: T) => IPromise<U>
 >value : T
 }
-declare function load(name: string): Promise<string>;
->load : (name: string) => Promise<string>
+declare function load(name: string): CPromise<string>;
+>load : (name: string) => CPromise<string>
 >name : string
 
 declare function convert(s: string): IPromise<number>;
@@ -22,13 +22,13 @@ declare function convert(s: string): IPromise<number>;
 >s : string
 
 var $$x = load("something").then(s => convert(s));
->$$x : any
->load("something").then(s => convert(s)) : any
->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") : Promise<string>
->load : (name: string) => Promise<string>
+>$$x : CPromise<unknown>
+>load("something").then(s => convert(s)) : CPromise<unknown>
+>load("something").then : <U>(success?: (value: string) => CPromise<U>) => CPromise<U>
+>load("something") : CPromise<string>
+>load : (name: string) => CPromise<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 : <U>(success?: (value: string) => CPromise<U>) => CPromise<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 73d2f703461..6a502788664 100644
--- a/tests/baselines/reference/promiseTypeStrictNull.types
+++ b/tests/baselines/reference/promiseTypeStrictNull.types
@@ -104,9 +104,9 @@ async function F() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -169,9 +169,9 @@ async function I() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -182,231 +182,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -414,9 +414,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
@@ -424,9 +424,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
@@ -434,9 +434,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
@@ -444,18 +444,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
@@ -463,55 +463,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -519,9 +519,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
@@ -529,9 +529,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
@@ -539,9 +539,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
@@ -549,18 +549,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
@@ -568,37 +568,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -606,9 +606,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
@@ -616,9 +616,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
@@ -627,9 +627,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
@@ -638,9 +638,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
@@ -649,9 +649,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
@@ -660,9 +660,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
@@ -670,9 +670,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
@@ -681,39 +681,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -721,9 +721,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
@@ -731,9 +731,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
@@ -742,9 +742,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
@@ -753,9 +753,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
@@ -764,9 +764,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
@@ -775,9 +775,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
@@ -785,9 +785,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
@@ -796,39 +796,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -836,9 +836,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
@@ -846,9 +846,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
@@ -857,9 +857,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
@@ -868,9 +868,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
@@ -879,9 +879,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
@@ -890,9 +890,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
@@ -900,9 +900,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
@@ -911,39 +911,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -951,9 +951,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
@@ -961,9 +961,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
@@ -972,9 +972,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
@@ -983,9 +983,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
@@ -994,9 +994,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
@@ -1005,9 +1005,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
@@ -1015,9 +1015,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
@@ -1026,57 +1026,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -1084,9 +1084,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
@@ -1094,9 +1094,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
@@ -1104,9 +1104,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
@@ -1114,18 +1114,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
@@ -1133,37 +1133,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -1171,9 +1171,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
@@ -1181,9 +1181,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
@@ -1192,9 +1192,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
@@ -1203,9 +1203,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
@@ -1214,9 +1214,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
@@ -1225,9 +1225,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
@@ -1235,9 +1235,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
@@ -1246,72 +1246,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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
@@ -1319,14 +1319,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
@@ -1334,14 +1334,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
@@ -1349,14 +1349,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
@@ -1364,28 +1364,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
@@ -1393,80 +1393,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1474,14 +1474,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1489,14 +1489,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => undefined : () => undefined
 >undefined : undefined
@@ -1504,14 +1504,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => null : () => null
 >null : null
@@ -1519,28 +1519,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1548,38 +1548,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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(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 : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<T>
+>Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<T>
+>reject : <T = never>(reason?: any) => Promise<awaited T>
 >1 : 1
 
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.types b/tests/baselines/reference/promiseVoidErrorCallback.types
index a1388cb04ef..ee9a6808b5d 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.types
+++ b/tests/baselines/reference/promiseVoidErrorCallback.types
@@ -19,9 +19,9 @@ function f1(): Promise<T1> {
 
     return Promise.resolve({ __t1: "foo_t1" });
 >Promise.resolve({ __t1: "foo_t1" }) : Promise<{ __t1: string; }>
->Promise.resolve : { <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"
@@ -44,14 +44,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
@@ -61,7 +61,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
 
diff --git a/tests/baselines/reference/promises.types b/tests/baselines/reference/promises.types
index 0640f013549..0850bb7307a 100644
--- a/tests/baselines/reference/promises.types
+++ b/tests/baselines/reference/promises.types
@@ -1,12 +1,12 @@
 === tests/cases/compiler/promises.ts ===
 interface Promise<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>; }
 >success : (value: T) => U
 >value : 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) => 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>; }
 >success : (value: T) => Promise<U>
 >value : T
 
diff --git a/tests/baselines/reference/promisesWithConstraints.types b/tests/baselines/reference/promisesWithConstraints.types
index 367cd6a61a6..2aa591d5dff 100644
--- a/tests/baselines/reference/promisesWithConstraints.types
+++ b/tests/baselines/reference/promisesWithConstraints.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/promisesWithConstraints.ts ===
 interface Promise<T> {
     then<U>(cb: (x: 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>(cb: (x: 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>(cb: (x: T) => Promise<U>): Promise<U>; }
 >cb : (x: T) => Promise<U>
 >x : T
 }
diff --git a/tests/baselines/reference/specializationError.types b/tests/baselines/reference/specializationError.types
index 8f0b5747bfa..166806766b7 100644
--- a/tests/baselines/reference/specializationError.types
+++ b/tests/baselines/reference/specializationError.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/specializationError.ts ===
 interface Promise<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; }
 >value : T
 }
 
diff --git a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types
index 3f1ef83a0ae..7594f117dec 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 = { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>import("package").then : <TResult1 = { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: { default: (x: number) => string; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >import("package") : Promise<{ default: (x: number) => string; }>
 >"package" : "package"
->then : <TResult1 = { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>then : <TResult1 = { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: { default: (x: number) => string; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >({default: foo}) => foo(42) : ({ default: foo }: { 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 061342eaf44..cdcbe306a45 100644
--- a/tests/baselines/reference/transformNestedGeneratorsWithTry.types
+++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.types
@@ -16,9 +16,9 @@ async function a(): Bluebird<void> {
         await Bluebird.resolve(); // -- remove this and it compiles
 >await Bluebird.resolve() : void
 >Bluebird.resolve() : Promise<void>
->Bluebird.resolve : { <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.es2018.1.types b/tests/baselines/reference/types.asyncGenerators.es2018.1.types
index 3c6e51c56d2..d1cdb28fb58 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.1.types
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.1.types
@@ -21,9 +21,9 @@ async function * inferReturnType4() {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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() {
@@ -89,9 +89,9 @@ const assignability2: () => AsyncIterableIterator<number> = async function * ()
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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
 
 };
@@ -114,9 +114,9 @@ const assignability4: () => AsyncIterableIterator<number> = async function * ()
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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
 
 };
@@ -149,9 +149,9 @@ const assignability7: () => AsyncIterable<number> = async function * () {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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
 
 };
@@ -174,9 +174,9 @@ const assignability9: () => AsyncIterable<number> = async function * () {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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
 
 };
@@ -209,9 +209,9 @@ const assignability12: () => AsyncIterator<number> = async function * () {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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
 
 };
@@ -234,9 +234,9 @@ const assignability14: () => AsyncIterator<number> = async function * () {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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
 
 };
@@ -266,9 +266,9 @@ async function * explicitReturnType2(): AsyncIterableIterator<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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> {
@@ -287,9 +287,9 @@ async function * explicitReturnType4(): AsyncIterableIterator<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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> {
@@ -316,9 +316,9 @@ async function * explicitReturnType7(): AsyncIterable<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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> {
@@ -337,9 +337,9 @@ async function * explicitReturnType9(): AsyncIterable<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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> {
@@ -366,9 +366,9 @@ async function * explicitReturnType12(): AsyncIterator<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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> {
@@ -387,9 +387,9 @@ async function * explicitReturnType14(): AsyncIterator<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <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> {
@@ -425,9 +425,9 @@ 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
 }
 async function * nextType1(): { next(...args: [] | [number | PromiseLike<number>]): any } {
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.types b/tests/baselines/reference/types.asyncGenerators.es2018.2.types
index 83524871199..d5761b3caab 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.2.types
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.types
@@ -20,9 +20,9 @@ async function * inferReturnType3() {
     yield* Promise.resolve([1, 2]);
 >yield* Promise.resolve([1, 2]) : any
 >Promise.resolve([1, 2]) : Promise<number[]>
->Promise.resolve : { <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, 2] : number[]
 >1 : 1
 >2 : 2
diff --git a/tests/baselines/reference/unionAndIntersectionInference1.types b/tests/baselines/reference/unionAndIntersectionInference1.types
index 72d60545e6a..002fa8019e2 100644
--- a/tests/baselines/reference/unionAndIntersectionInference1.types
+++ b/tests/baselines/reference/unionAndIntersectionInference1.types
@@ -190,12 +190,12 @@ const createTestAsync = (): Promise<ITest> => Promise.resolve().then(() => ({ na
 >createTestAsync : () => Promise<ITest>
 >(): Promise<ITest> => Promise.resolve().then(() => ({ name: 'test' })) : () => Promise<ITest>
 >Promise.resolve().then(() => ({ name: 'test' })) : Promise<ITest | { name: "test"; }>
->Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Promise.resolve() : Promise<void>
->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>; }
->then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
+>then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => ({ name: 'test' }) : () => { name: "test"; }
 >({ name: 'test' }) : { name: "test"; }
 >{ name: 'test' } : { name: "test"; }
diff --git a/tests/baselines/reference/uniqueSymbols.types b/tests/baselines/reference/uniqueSymbols.types
index a321593c11a..ad5eef9f913 100644
--- a/tests/baselines/reference/uniqueSymbols.types
+++ b/tests/baselines/reference/uniqueSymbols.types
@@ -400,9 +400,9 @@ const constInitToLReadonlyNestedTypeWithIndexedAccess: L["nested"]["readonlyNest
 const promiseForConstCall = Promise.resolve(constCall);
 >promiseForConstCall : Promise<unique symbol>
 >Promise.resolve(constCall) : Promise<unique symbol>
->Promise.resolve : { <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>; }
 >constCall : unique symbol
 
 const arrayOfConstCall = [constCall];
diff --git a/tests/baselines/reference/uniqueSymbolsDeclarations.types b/tests/baselines/reference/uniqueSymbolsDeclarations.types
index bacdafc5680..4d0274cd79a 100644
--- a/tests/baselines/reference/uniqueSymbolsDeclarations.types
+++ b/tests/baselines/reference/uniqueSymbolsDeclarations.types
@@ -393,9 +393,9 @@ const constInitToLReadonlyNestedTypeWithIndexedAccess: L["nested"]["readonlyNest
 const promiseForConstCall = Promise.resolve(constCall);
 >promiseForConstCall : Promise<unique symbol>
 >Promise.resolve(constCall) : Promise<unique symbol>
->Promise.resolve : { <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>; }
 >constCall : unique symbol
 
 const arrayOfConstCall = [constCall];
diff --git a/tests/cases/compiler/asyncFunctionReturnType.ts b/tests/cases/compiler/asyncFunctionReturnType.ts
index 3bd7a0e998a..94ed95c833d 100644
--- a/tests/cases/compiler/asyncFunctionReturnType.ts
+++ b/tests/cases/compiler/asyncFunctionReturnType.ts
@@ -63,14 +63,14 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
     return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
 }
 
-async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
     return obj[key];
 }
 
-async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
     return Promise.resolve(obj[key]);
 }
 
-async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
+async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<awaited TObj[K]> {
     return Promise.resolve<TObj[K]>(obj[key]);
 }
\ No newline at end of file
diff --git a/tests/cases/compiler/promiseTypeInference.ts b/tests/cases/compiler/promiseTypeInference.ts
index f26a3eb0256..49d83ef0094 100644
--- a/tests/cases/compiler/promiseTypeInference.ts
+++ b/tests/cases/compiler/promiseTypeInference.ts
@@ -1,10 +1,10 @@
-declare class Promise<T> {
-    then<U>(success?: (value: T) => Promise<U>): Promise<U>;
+declare class CPromise<T> {
+    then<U>(success?: (value: T) => CPromise<U>): CPromise<U>;
 }
 interface IPromise<T> {
     then<U>(success?: (value: T) => IPromise<U>): IPromise<U>;
 }
-declare function load(name: string): Promise<string>;
+declare function load(name: string): CPromise<string>;
 declare function convert(s: string): IPromise<number>;
 
 var $$x = load("something").then(s => convert(s));
diff --git a/tests/cases/conformance/types/awaited/awaited.ts b/tests/cases/conformance/types/awaited/awaited.ts
new file mode 100644
index 00000000000..91564b4945c
--- /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