diff --git a/.eslintignore b/.eslintignore
index 10b1ba1197ccb..1f3ae7ecb5de0 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -2,11 +2,3 @@
 /tests/**
 /lib/**
 /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
-/src/lib/es2018.promise.d.ts
-/src/lib/es2020.promise.d.ts
-/src/lib/esnext.promise.d.ts
\ No newline at end of file
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 59bbab5eb5e31..e0672300f1cd4 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -686,7 +686,6 @@ namespace ts {
         const literalTypes = createMap<LiteralType>();
         const indexedAccessTypes = createMap<IndexedAccessType>();
         const substitutionTypes = createMap<SubstitutionType>();
-        const awaitedTypes = createMap<AwaitedType>();
         const evolvingArrayTypes: EvolvingArrayType[] = [];
         const undefinedProperties = createMap<Symbol>() as UnderscoreEscapedMap<Symbol>;
 
@@ -4271,11 +4270,6 @@ namespace ts {
                     context.approximateLength += 2;
                     return createIndexedAccessTypeNode(objectTypeNode, indexTypeNode);
                 }
-                if (type.flags & TypeFlags.Awaited) {
-                    const awaitedTypeNode = typeToTypeNodeHelper((<AwaitedType>type).awaitedType, 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;
@@ -10124,10 +10118,6 @@ namespace ts {
                     constraintDepth--;
                     return result;
                 }
-                if (t.flags & TypeFlags.Awaited) {
-                    const basePromiseType = getBaseConstraint((<AwaitedType>t).awaitedType);
-                    return basePromiseType ? getAwaitedType(basePromiseType) : undefined;
-                }
                 if (t.flags & TypeFlags.Substitution) {
                     return getBaseConstraint((<SubstitutionType>t).substitute);
                 }
@@ -12460,9 +12450,6 @@ 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);
                 }
@@ -14022,9 +14009,6 @@ namespace ts {
             if (flags & TypeFlags.Conditional) {
                 return getConditionalTypeInstantiation(<ConditionalType>type, combineTypeMappers((<ConditionalType>type).mapper, mapper));
             }
-            if (flags & TypeFlags.Awaited) {
-                return getAwaitedType(instantiateType((<AwaitedType>type).awaitedType, mapper)) ?? unknownType;
-            }
             if (flags & TypeFlags.Substitution) {
                 const maybeVariable = instantiateType((<SubstitutionType>type).baseType, mapper);
                 if (maybeVariable.flags & TypeFlags.TypeVariable) {
@@ -15832,8 +15816,7 @@ namespace ts {
                 if (outofbandVarianceMarkerHandler) {
                     originalHandler = outofbandVarianceMarkerHandler;
                     outofbandVarianceMarkerHandler = onlyUnreliable => {
-                        propagatingVarianceFlags |=
-                            onlyUnreliable ? RelationComparisonResult.ReportsUnreliable : RelationComparisonResult.ReportsUnmeasurable;
+                        propagatingVarianceFlags |= onlyUnreliable ? RelationComparisonResult.ReportsUnreliable : RelationComparisonResult.ReportsUnmeasurable;
                         return originalHandler!(onlyUnreliable);
                     };
                 }
@@ -15964,17 +15947,6 @@ namespace ts {
                         }
                     }
                 }
-                else if (target.flags & TypeFlags.Awaited && source.flags & TypeFlags.Awaited) {
-                    const targetType = (<AwaitedType>target).awaitedType;
-                    const sourceType = instantiateType((<AwaitedType>source).awaitedType, makeFunctionTypeMapper(reportUnreliableMarkers));
-                    // An `awaited S` is related to an `awaited T` if `S` is related to `T`:
-                    //
-                    //  S <: T ⇒ awaited S <: awaited T
-                    //
-                    if (result = isRelatedTo(sourceType, targetType, 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);
@@ -16093,21 +16065,6 @@ 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).awaitedType);
-                    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)) {
@@ -16988,11 +16945,13 @@ namespace ts {
                         variance = VarianceFlags.Independent;
                     }
                     outofbandVarianceMarkerHandler = oldHandler;
-                    if (unmeasurable) {
-                        variance |= VarianceFlags.Unmeasurable;
-                    }
-                    if (unreliable) {
-                        variance |= VarianceFlags.Unreliable;
+                    if (unmeasurable || unreliable) {
+                        if (unmeasurable) {
+                            variance |= VarianceFlags.Unmeasurable;
+                        }
+                        if (unreliable) {
+                            variance |= VarianceFlags.Unreliable;
+                        }
                     }
                     variances.push(variance);
                 }
@@ -18347,9 +18306,6 @@ 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).awaitedType, (<AwaitedType>target).awaitedType);
-                }
                 else if (target.flags & TypeFlags.Conditional) {
                     const savePriority = priority;
                     priority |= contravariant ? InferencePriority.ContravariantConditional : 0;
@@ -18357,10 +18313,6 @@ namespace ts {
                     inferToMultipleTypes(source, targetTypes, target.flags);
                     priority = savePriority;
                 }
-                else if (target.flags & TypeFlags.Awaited) {
-                    inferFromTypes(source, (<AwaitedType>target).awaitedType);
-                    inferFromTypes(source, createPromiseLikeType((<AwaitedType>target).awaitedType));
-                }
                 else if (target.flags & TypeFlags.UnionOrIntersection) {
                     inferToMultipleTypes(source, (<UnionOrIntersectionType>target).types, target.flags);
                 }
@@ -18489,32 +18441,10 @@ namespace ts {
                 return typeVariable;
             }
 
-            function isPromiseForType(promiseType: Type, promisedType: Type) {
-                return isThenableType(promiseType) && unwrapAwaitedType(getPromisedTypeOfPromise(promiseType) ?? errorType) === promisedType;
-            }
-
             function inferToMultipleTypes(source: Type, targets: Type[], targetFlags: TypeFlags) {
                 let typeVariableCount = 0;
                 if (targetFlags & TypeFlags.Union) {
                     let nakedTypeVariable: Type | undefined;
-                    for (const t of targets) {
-                        if (getInferenceInfoForType(t)) {
-                            nakedTypeVariable = t;
-                            typeVariableCount++;
-                        }
-                    }
-                    // To better support backwards compatibility with the new `awaited` type, we detect a target
-                    // union of exactly `T | PromiseLike<T>` (for any compatible `PromiseLike`). When encountered,
-                    // we infer from source to the type parameter `T`, where each type of source is mapped to extract
-                    // the promised type of any promise (e.g., `string | Promise<number>` becomes `string | number`).
-                    if (typeVariableCount === 1 && targets.length === 2) {
-                        for (const t of targets) {
-                            if (!getInferenceInfoForType(t) && isPromiseForType(t, nakedTypeVariable!)) {
-                                inferFromTypes(mapType(source, s => getPromisedTypeOfPromise(s) ?? s), nakedTypeVariable!);
-                                return;
-                            }
-                        }
-                    }
                     const sources = source.flags & TypeFlags.Union ? (<UnionType>source).types : [source];
                     const matched = new Array<boolean>(sources.length);
                     let inferenceCircularity = false;
@@ -18523,7 +18453,11 @@ namespace ts {
                     // equal priority (i.e. of equal quality) to what we would infer for a naked type
                     // parameter.
                     for (const t of targets) {
-                        if (!getInferenceInfoForType(t)) {
+                        if (getInferenceInfoForType(t)) {
+                            nakedTypeVariable = t;
+                            typeVariableCount++;
+                        }
+                        else {
                             for (let i = 0; i < sources.length; i++) {
                                 const saveInferencePriority = inferencePriority;
                                 inferencePriority = InferencePriority.MaxValue;
@@ -21840,10 +21774,7 @@ namespace ts {
                 const contextualReturnType = getContextualReturnType(func);
                 if (contextualReturnType) {
                     if (functionFlags & FunctionFlags.Async) { // Async function
-                        let contextualAwaitedType = getAwaitedTypeOfPromise(contextualReturnType);
-                        if (contextualAwaitedType && contextualAwaitedType.flags & TypeFlags.Awaited) {
-                            contextualAwaitedType = (<AwaitedType>contextualAwaitedType).awaitedType;
-                        }
+                        const contextualAwaitedType = getAwaitedTypeOfPromise(contextualReturnType);
                         return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
                     }
                     return contextualReturnType; // Regular function
@@ -21855,10 +21786,7 @@ namespace ts {
         function getContextualTypeForAwaitOperand(node: AwaitExpression): Type | undefined {
             const contextualType = getContextualType(node);
             if (contextualType) {
-                let contextualAwaitedType = getAwaitedType(contextualType);
-                if (contextualAwaitedType && contextualAwaitedType.flags & TypeFlags.Awaited) {
-                    contextualAwaitedType = (<AwaitedType>contextualAwaitedType).awaitedType;
-                }
+                const contextualAwaitedType = getAwaitedType(contextualType);
                 return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
             }
             return undefined;
@@ -26777,7 +26705,7 @@ namespace ts {
             const globalPromiseType = getGlobalPromiseType(/*reportErrors*/ true);
             if (globalPromiseType !== emptyGenericType) {
                 // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type
-                promisedType = unwrapAwaitedType(getAwaitedType(promisedType) || unknownType);
+                promisedType = getAwaitedType(promisedType) || unknownType;
                 return createTypeReference(globalPromiseType, [promisedType]);
             }
 
@@ -26789,7 +26717,7 @@ namespace ts {
             const globalPromiseLikeType = getGlobalPromiseLikeType(/*reportErrors*/ true);
             if (globalPromiseLikeType !== emptyGenericType) {
                 // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type
-                promisedType = unwrapAwaitedType(getAwaitedType(promisedType) || unknownType);
+                promisedType = getAwaitedType(promisedType) || unknownType;
                 return createTypeReference(globalPromiseLikeType, [promisedType]);
             }
 
@@ -30200,9 +30128,8 @@ namespace ts {
                 return typeAsPromise.promisedTypeOfPromise;
             }
 
-            if (isReferenceToType(type, getGlobalPromiseType(/*reportErrors*/ false)) ||
-                isReferenceToType(type, getGlobalPromiseLikeType(/*reportErrors*/ false))) {
-                return typeAsPromise.promisedTypeOfPromise = getAwaitedType(getTypeArguments(<GenericType>type)[0], errorNode);
+            if (isReferenceToType(type, getGlobalPromiseType(/*reportErrors*/ false))) {
+                return typeAsPromise.promisedTypeOfPromise = getTypeArguments(<GenericType>type)[0];
             }
 
             const thenFunction = getTypeOfPropertyOfType(type, "then" as __String)!; // TODO: GH#18217
@@ -30246,30 +30173,6 @@ namespace ts {
             return awaitedType || errorType;
         }
 
-        /**
-         * Gets or creates an `awaited T` type for a generic type.
-         *
-         * The "awaited type" of a generic type cannot be determined until it is instantiated. As
-         * a result, an `AwaitedType` for the generic type is created that can be instantiated
-         * or related later.
-         */
-        function getAwaitedTypeForGenericType(type: InstantiableType) {
-            const typeId = "" + type.id;
-            let awaitedType = awaitedTypes.get(typeId);
-            if (!awaitedType) {
-                awaitedType = <AwaitedType>createType(TypeFlags.Awaited);
-                awaitedType.awaitedType = type;
-                awaitedTypes.set(typeId, awaitedType);
-            }
-            return awaitedType;
-        }
-
-        function unwrapAwaitedType(type: Type): Type {
-            return type.flags & TypeFlags.Union ?
-                mapType(type, unwrapAwaitedType) :
-                type.flags & TypeFlags.Awaited ? (<AwaitedType>type).awaitedType : type;
-        }
-
         /**
          * Determines whether a type has a callable `then` member.
          */
@@ -30278,33 +30181,6 @@ namespace ts {
             return !!thenFunction && getSignaturesOfType(getTypeWithFacts(thenFunction, TypeFacts.NEUndefinedOrNull), SignatureKind.Call).length > 0;
         }
 
-        /**
-         * Determines whether a type is a generic type whose base constraint could possibly resolve to a different
-         * type when awaited. A type is a generic "thenable" type when all of the following conditions are met:
-         * - The type is a generic object type,
-         * - AND one of the following conditions are met
-         *   - The type has no base constraint,
-         *   - OR The base constraint of the type is `any`, `unknown`, `object`, or the empty object `{}`,
-         *   - OR The base constraint has a callable `then` member.
-         * This behavior is not entirely sound, as a `T extends { x: any }` could be instantiated with a
-         * subtype that has a callable `then`, however this is unlikely in practice and this slightly more unsound
-         * behavior is much more developer friendly.
-         */
-        function isGenericAwaitableType(type: Type): boolean {
-            if (isGenericObjectType(type)) {
-                if (type.flags & TypeFlags.Intersection) {
-                    return some((type as IntersectionType).types, isGenericAwaitableType);
-                }
-                const baseConstraint = getBaseConstraintOfType(type);
-                return !baseConstraint ||
-                    !!(baseConstraint.flags & (TypeFlags.AnyOrUnknown | TypeFlags.NonPrimitive)) ||
-                    baseConstraint === emptyObjectType ||
-                    baseConstraint === emptyGenericType ||
-                    isThenableType(baseConstraint);
-            }
-            return false;
-        }
-
         /**
          * Gets the "awaited type" of a type.
          *
@@ -30313,24 +30189,13 @@ namespace ts {
          * 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.
+         * This is used to reflect the runtime behavior of the `await` keyword.
          */
         function getAwaitedType(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage, arg0?: string | number): Type | undefined {
             if (isTypeAny(type)) {
                 return type;
             }
 
-            // If the type is already an awaited type, return it.
-            //
-            // For example:
-            //
-            //   awaited T -> awaited T
-            //
-            if (type.flags & TypeFlags.Awaited) {
-                return type;
-            }
-
             const typeAsAwaitable = <PromiseOrAwaitableType>type;
             if (typeAsAwaitable.awaitedTypeOfType) {
                 return typeAsAwaitable.awaitedTypeOfType;
@@ -30338,41 +30203,11 @@ namespace ts {
 
             // 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);
         }
 
         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;
-            }
-
-            // 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 (isGenericAwaitableType(type)) {
-                return getAwaitedTypeForGenericType(<TypeVariable>type);
-            }
-
             const typeAsAwaitable = <PromiseOrAwaitableType>type;
             if (typeAsAwaitable.awaitedTypeOfType) {
                 return typeAsAwaitable.awaitedTypeOfType;
@@ -32615,7 +32450,7 @@ namespace ts {
             const isGenerator = !!(functionFlags & FunctionFlags.Generator);
             const isAsync = !!(functionFlags & FunctionFlags.Async);
             return isGenerator ? getIterationTypeOfGeneratorFunctionReturnType(IterationTypeKind.Return, returnType, isAsync) || errorType :
-                isAsync ? unwrapAwaitedType(getAwaitedType(returnType) || errorType) :
+                isAsync ? getPromisedTypeOfPromise(returnType) || errorType :
                 returnType;
         }
 
@@ -32654,7 +32489,7 @@ namespace ts {
                 else if (getReturnTypeFromAnnotation(func)) {
                     const unwrappedReturnType = unwrapReturnType(returnType, functionFlags);
                     const unwrappedExprType = functionFlags & FunctionFlags.Async
-                        ? unwrapAwaitedType(checkAwaitedType(exprType, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member))
+                        ? checkAwaitedType(exprType, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)
                         : exprType;
                     if (unwrappedReturnType) {
                         // If the function has a return type, but promisedType is
diff --git a/src/compiler/factoryPublic.ts b/src/compiler/factoryPublic.ts
index bd95b82bc5e07..49f7f6255c7f0 100644
--- a/src/compiler/factoryPublic.ts
+++ b/src/compiler/factoryPublic.ts
@@ -939,8 +939,8 @@ namespace ts {
     }
 
     export function createTypeOperatorNode(type: TypeNode): TypeOperatorNode;
-    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) {
+    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) {
         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 1615ce6eeeca5..24efb0c529790 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -3297,7 +3297,7 @@ namespace ts {
             return finishNode(postfix);
         }
 
-        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword) {
+        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {
             const node = <TypeOperatorNode>createNode(SyntaxKind.TypeOperator);
             parseExpected(operator);
             node.operator = operator;
@@ -3320,7 +3320,6 @@ 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 f12a05cf2cc78..fef7179f60828 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -146,7 +146,6 @@ 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 8b6f5f8fa5af6..978baed990dff 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -107,7 +107,6 @@ namespace ts {
         | SyntaxKind.YieldKeyword
         | SyntaxKind.AsyncKeyword
         | SyntaxKind.AwaitKeyword
-        | SyntaxKind.AwaitedKeyword
         | SyntaxKind.OfKeyword;
 
     export type JsxTokenSyntaxKind =
@@ -262,7 +261,6 @@ namespace ts {
         AnyKeyword,
         AsyncKeyword,
         AwaitKeyword,
-        AwaitedKeyword,
         BooleanKeyword,
         ConstructorKeyword,
         DeclareKeyword,
@@ -1320,7 +1318,7 @@ namespace ts {
 
     export interface TypeOperatorNode extends TypeNode {
         kind: SyntaxKind.TypeOperator;
-        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword;
+        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
         type: TypeNode;
     }
 
@@ -4352,7 +4350,6 @@ 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,
@@ -4382,7 +4379,7 @@ namespace ts {
         UnionOrIntersection = Union | Intersection,
         StructuredType = Object | Union | Intersection,
         TypeVariable = TypeParameter | IndexedAccess,
-        InstantiableNonPrimitive = TypeVariable | Conditional | Substitution | Awaited,
+        InstantiableNonPrimitive = TypeVariable | Conditional | Substitution,
         InstantiablePrimitive = Index,
         Instantiable = InstantiableNonPrimitive | InstantiablePrimitive,
         StructuredOrInstantiable = StructuredType | Instantiable,
@@ -4827,11 +4824,6 @@ namespace ts {
         substitute: Type;   // Type to substitute for type parameter
     }
 
-    // awaited T (TypeFlags.Awaited)
-    export interface AwaitedType extends InstantiableType {
-        awaitedType: Type;
-    }
-
     /* @internal */
     export const enum JsxReferenceKind {
         Component,
diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index b3bf6ff1edc43..374aad93229db 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -203,7 +203,7 @@ interface PromiseConstructor {
      * @param values An iterable of Promises.
      * @returns A new Promise.
      */
-    all<T>(values: Iterable<T | PromiseLike<T>>): Promise<(awaited T)[]>;
+    all<T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -211,7 +211,15 @@ interface PromiseConstructor {
      * @param values An iterable of Promises.
      * @returns A new Promise.
      */
-    race<T>(values: Iterable<T | PromiseLike<T>>): Promise<awaited T>;
+    race<T>(values: Iterable<T>): Promise<T extends PromiseLike<infer U> ? U : T>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An iterable of Promises.
+     * @returns A new Promise.
+     */
+    race<T>(values: Iterable<T | PromiseLike<T>>): Promise<T>;
 }
 
 declare namespace Reflect {
diff --git a/src/lib/es2015.promise.d.ts b/src/lib/es2015.promise.d.ts
index e149e72b710db..9c99f6be1d488 100644
--- a/src/lib/es2015.promise.d.ts
+++ b/src/lib/es2015.promise.d.ts
@@ -10,7 +10,7 @@ interface PromiseConstructor {
      * a resolve callback used to resolve the promise with a value or the result of another promise,
      * and a reject callback used to reject the promise with a provided reason or error.
      */
-    new <T>(executor: (resolve: (value?: T | PromiseLike<T> | awaited T) => void, reject: (reason?: any) => void) => void): Promise<T>;
+    new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -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<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9, awaited T10]>;
+    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]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -26,63 +26,55 @@ 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<[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
-     * resolve, or rejected when any Promise is rejected.
-     * @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<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8]>;
-    
+    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]>;
+
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
      * resolve, or rejected when any Promise is rejected.
      * @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<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7]>;
-    
+    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]>;
+
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
      * resolve, or rejected when any Promise is rejected.
      * @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<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>;
-    
+    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]>;
+
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
      * resolve, or rejected when any Promise is rejected.
      * @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<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>;
-    
+    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]>;
+
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
      * resolve, or rejected when any Promise is rejected.
      * @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<[awaited T1, awaited T2, awaited T3, awaited T4]>;
-    
+    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]>;
+
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
      * resolve, or rejected when any Promise is rejected.
      * @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<[awaited T1, awaited T2, awaited T3]>;
-    
+    all<T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>;
+
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
      * resolve, or rejected when any Promise is rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[awaited T1, awaited T2]>;
+    all<T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -90,7 +82,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: awaited T[P] }>;
+    all<T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -98,10 +90,10 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T>(values: readonly (T | PromiseLike<T>)[]): Promise<(awaited T)[]>;
+    all<T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>;
 
     // see: lib.es2015.iterable.d.ts
-    // all<T>(values: Iterable<T | PromiseLike<T>>): Promise<(awaited T)[]>;
+    // all<T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -109,24 +101,24 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T>(values: readonly (T | PromiseLike<T>)[]): Promise<awaited T>;
+    race<T>(values: readonly T[]): Promise<T extends PromiseLike<infer U> ? U : T>;
 
     // see: lib.es2015.iterable.d.ts
-    // race<T>(values: Iterable<T | PromiseLike<T>>): Promise<awaited T>;
+    // race<T>(values: Iterable<T>): Promise<T extends PromiseLike<infer U> ? U : 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<awaited T>;
+    reject<T = never>(reason?: any): Promise<T>;
 
     /**
      * Creates a new resolved promise for the provided value.
      * @param value A promise.
      * @returns A promise whose internal state matches the provided promise.
      */
-    resolve<T>(value: T | PromiseLike<T>): Promise<awaited T>;
+    resolve<T>(value: T | PromiseLike<T>): Promise<T>;
 
     /**
      * Creates a new resolved promise .
diff --git a/src/lib/es2018.promise.d.ts b/src/lib/es2018.promise.d.ts
index 84b99d895026b..28f903870b67c 100644
--- a/src/lib/es2018.promise.d.ts
+++ b/src/lib/es2018.promise.d.ts
@@ -8,5 +8,5 @@ interface Promise<T> {
      * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
      * @returns A Promise for the completion of the callback.
      */
-    finally(onfinally?: (() => void | PromiseLike<void>) | undefined | null): Promise<awaited T>
+    finally(onfinally?: (() => void) | undefined | null): Promise<T>
 }
diff --git a/src/lib/es2020.promise.d.ts b/src/lib/es2020.promise.d.ts
index 4d9e20f451ff9..a996a99603e5d 100644
--- a/src/lib/es2020.promise.d.ts
+++ b/src/lib/es2020.promise.d.ts
@@ -17,7 +17,8 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<awaited T[P]> }>;
+    allSettled<T extends readonly unknown[] | readonly [unknown]>(values: T):
+        Promise<{ -readonly [P in keyof T]: PromiseSettledResult<T[P] extends PromiseLike<infer U> ? U : T[P]> }>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all
@@ -25,5 +26,5 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<awaited T>[]>;
+    allSettled<T>(values: Iterable<T>): Promise<PromiseSettledResult<T extends PromiseLike<infer U> ? U : T>[]>;
 }
diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
index 7cf2c00248c8b..9b981d69fc04e 100644
--- a/src/lib/es5.d.ts
+++ b/src/lib/es5.d.ts
@@ -1378,7 +1378,7 @@ declare type PropertyDecorator = (target: Object, propertyKey: string | symbol)
 declare type MethodDecorator = <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
 declare type ParameterDecorator = (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
 
-declare type PromiseConstructorLike = new <T>(executor: (resolve: (value?: T | PromiseLike<T> | awaited T) => void, reject: (reason?: any) => void) => void) => PromiseLike<T>;
+declare type PromiseConstructorLike = new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) => PromiseLike<T>;
 
 interface PromiseLike<T> {
     /**
@@ -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: awaited T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<awaited TResult1 | awaited TResult2>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | 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: awaited T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<awaited TResult1 | awaited TResult2>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | 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<awaited T | awaited TResult>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
 }
 
 interface ArrayLike<T> {
diff --git a/src/lib/esnext.promise.d.ts b/src/lib/esnext.promise.d.ts
index 6283558e7dd38..d18a16581426b 100644
--- a/src/lib/esnext.promise.d.ts
+++ b/src/lib/esnext.promise.d.ts
@@ -19,5 +19,5 @@ interface PromiseConstructor {
      * @param values An array or iterable of Promises.
      * @returns A new Promise.
      */
-    any<T>(values: (T | PromiseLike<T>)[] | Iterable<T | PromiseLike<T>>): Promise<awaited T>
+    any<T>(values: (T | PromiseLike<T>)[] | Iterable<T | PromiseLike<T>>): Promise<T>
 }
diff --git a/src/services/codefixes/inferFromUsage.ts b/src/services/codefixes/inferFromUsage.ts
index d0a47be96b7ab..0af71bbbb9ca0 100644
--- a/src/services/codefixes/inferFromUsage.ts
+++ b/src/services/codefixes/inferFromUsage.ts
@@ -1043,9 +1043,6 @@ 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).awaitedType, 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);
@@ -1062,7 +1059,6 @@ namespace ts.codefix {
             }
             const genericSigs = checker.getSignaturesOfType(genericType, SignatureKind.Call);
             const usageSigs = checker.getSignaturesOfType(usageType, SignatureKind.Call);
-            // allow for multiple overloads of `then`.
             if (genericSigs.length === 1 && usageSigs.length === 1) {
                 return inferFromSignatures(genericSigs[0], usageSigs[0], typeParameter);
             }
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index 3744fa68605c8..545fac4f8a159 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.AwaitedKeyword | 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.OfKeyword;
     export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;
     export enum SyntaxKind {
         Unknown = 0,
@@ -203,211 +203,210 @@ declare namespace ts {
         AnyKeyword = 125,
         AsyncKeyword = 126,
         AwaitKeyword = 127,
-        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,
-        JSDocImplementsTag = 309,
-        JSDocAuthorTag = 310,
-        JSDocClassTag = 311,
-        JSDocPublicTag = 312,
-        JSDocPrivateTag = 313,
-        JSDocProtectedTag = 314,
-        JSDocReadonlyTag = 315,
-        JSDocCallbackTag = 316,
-        JSDocEnumTag = 317,
-        JSDocParameterTag = 318,
-        JSDocReturnTag = 319,
-        JSDocThisTag = 320,
-        JSDocTypeTag = 321,
-        JSDocTemplateTag = 322,
-        JSDocTypedefTag = 323,
-        JSDocPropertyTag = 324,
-        SyntaxList = 325,
-        NotEmittedStatement = 326,
-        PartiallyEmittedExpression = 327,
-        CommaListExpression = 328,
-        MergeDeclarationMarker = 329,
-        EndOfDeclarationMarker = 330,
-        SyntheticReferenceExpression = 331,
-        Count = 332,
+        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,
+        JSDocImplementsTag = 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,
@@ -415,15 +414,15 @@ declare namespace ts {
         FirstReservedWord = 77,
         LastReservedWord = 112,
         FirstKeyword = 77,
-        LastKeyword = 153,
+        LastKeyword = 152,
         FirstFutureReservedWord = 113,
         LastFutureReservedWord = 121,
-        FirstTypeNode = 169,
-        LastTypeNode = 189,
+        FirstTypeNode = 168,
+        LastTypeNode = 188,
         FirstPunctuation = 18,
         LastPunctuation = 74,
         FirstToken = 0,
-        LastToken = 153,
+        LastToken = 152,
         FirstTriviaToken = 2,
         LastTriviaToken = 7,
         FirstLiteralToken = 8,
@@ -432,13 +431,13 @@ declare namespace ts {
         LastTemplateToken = 17,
         FirstBinaryOperator = 29,
         LastBinaryOperator = 74,
-        FirstStatement = 226,
-        LastStatement = 242,
-        FirstNode = 154,
-        FirstJSDocNode = 295,
-        LastJSDocNode = 324,
-        FirstJSDocTagNode = 307,
-        LastJSDocTagNode = 324,
+        FirstStatement = 225,
+        LastStatement = 241,
+        FirstNode = 153,
+        FirstJSDocNode = 294,
+        LastJSDocNode = 323,
+        FirstJSDocTagNode = 306,
+        LastJSDocTagNode = 323,
     }
     export enum NodeFlags {
         None = 0,
@@ -845,7 +844,7 @@ declare namespace ts {
     }
     export interface TypeOperatorNode extends TypeNode {
         kind: SyntaxKind.TypeOperator;
-        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword;
+        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
         type: TypeNode;
     }
     export interface IndexedAccessTypeNode extends TypeNode {
@@ -2364,7 +2363,6 @@ declare namespace ts {
         Conditional = 16777216,
         Substitution = 33554432,
         NonPrimitive = 67108864,
-        Awaited = 134217728,
         Literal = 2944,
         Unit = 109440,
         StringOrNumberLiteral = 384,
@@ -2379,11 +2377,11 @@ declare namespace ts {
         UnionOrIntersection = 3145728,
         StructuredType = 3670016,
         TypeVariable = 8650752,
-        InstantiableNonPrimitive = 193200128,
+        InstantiableNonPrimitive = 58982400,
         InstantiablePrimitive = 4194304,
-        Instantiable = 197394432,
-        StructuredOrInstantiable = 201064448,
-        Narrowable = 268188671,
+        Instantiable = 63176704,
+        StructuredOrInstantiable = 66846720,
+        Narrowable = 133970943,
         NotUnionOrUnit = 67637251,
     }
     export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
@@ -2531,9 +2529,6 @@ declare namespace ts {
         baseType: Type;
         substitute: Type;
     }
-    export interface AwaitedType extends InstantiableType {
-        awaitedType: Type;
-    }
     export enum SignatureKind {
         Call = 0,
         Construct = 1
@@ -4075,7 +4070,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 | SyntaxKind.AwaitedKeyword, type: TypeNode): TypeOperatorNode;
+    function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, 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 1e606168e0f71..45bb3f9913c8d 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.AwaitedKeyword | 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.OfKeyword;
     export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;
     export enum SyntaxKind {
         Unknown = 0,
@@ -203,211 +203,210 @@ declare namespace ts {
         AnyKeyword = 125,
         AsyncKeyword = 126,
         AwaitKeyword = 127,
-        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,
-        JSDocImplementsTag = 309,
-        JSDocAuthorTag = 310,
-        JSDocClassTag = 311,
-        JSDocPublicTag = 312,
-        JSDocPrivateTag = 313,
-        JSDocProtectedTag = 314,
-        JSDocReadonlyTag = 315,
-        JSDocCallbackTag = 316,
-        JSDocEnumTag = 317,
-        JSDocParameterTag = 318,
-        JSDocReturnTag = 319,
-        JSDocThisTag = 320,
-        JSDocTypeTag = 321,
-        JSDocTemplateTag = 322,
-        JSDocTypedefTag = 323,
-        JSDocPropertyTag = 324,
-        SyntaxList = 325,
-        NotEmittedStatement = 326,
-        PartiallyEmittedExpression = 327,
-        CommaListExpression = 328,
-        MergeDeclarationMarker = 329,
-        EndOfDeclarationMarker = 330,
-        SyntheticReferenceExpression = 331,
-        Count = 332,
+        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,
+        JSDocImplementsTag = 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,
@@ -415,15 +414,15 @@ declare namespace ts {
         FirstReservedWord = 77,
         LastReservedWord = 112,
         FirstKeyword = 77,
-        LastKeyword = 153,
+        LastKeyword = 152,
         FirstFutureReservedWord = 113,
         LastFutureReservedWord = 121,
-        FirstTypeNode = 169,
-        LastTypeNode = 189,
+        FirstTypeNode = 168,
+        LastTypeNode = 188,
         FirstPunctuation = 18,
         LastPunctuation = 74,
         FirstToken = 0,
-        LastToken = 153,
+        LastToken = 152,
         FirstTriviaToken = 2,
         LastTriviaToken = 7,
         FirstLiteralToken = 8,
@@ -432,13 +431,13 @@ declare namespace ts {
         LastTemplateToken = 17,
         FirstBinaryOperator = 29,
         LastBinaryOperator = 74,
-        FirstStatement = 226,
-        LastStatement = 242,
-        FirstNode = 154,
-        FirstJSDocNode = 295,
-        LastJSDocNode = 324,
-        FirstJSDocTagNode = 307,
-        LastJSDocTagNode = 324,
+        FirstStatement = 225,
+        LastStatement = 241,
+        FirstNode = 153,
+        FirstJSDocNode = 294,
+        LastJSDocNode = 323,
+        FirstJSDocTagNode = 306,
+        LastJSDocTagNode = 323,
     }
     export enum NodeFlags {
         None = 0,
@@ -845,7 +844,7 @@ declare namespace ts {
     }
     export interface TypeOperatorNode extends TypeNode {
         kind: SyntaxKind.TypeOperator;
-        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.AwaitedKeyword;
+        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
         type: TypeNode;
     }
     export interface IndexedAccessTypeNode extends TypeNode {
@@ -2364,7 +2363,6 @@ declare namespace ts {
         Conditional = 16777216,
         Substitution = 33554432,
         NonPrimitive = 67108864,
-        Awaited = 134217728,
         Literal = 2944,
         Unit = 109440,
         StringOrNumberLiteral = 384,
@@ -2379,11 +2377,11 @@ declare namespace ts {
         UnionOrIntersection = 3145728,
         StructuredType = 3670016,
         TypeVariable = 8650752,
-        InstantiableNonPrimitive = 193200128,
+        InstantiableNonPrimitive = 58982400,
         InstantiablePrimitive = 4194304,
-        Instantiable = 197394432,
-        StructuredOrInstantiable = 201064448,
-        Narrowable = 268188671,
+        Instantiable = 63176704,
+        StructuredOrInstantiable = 66846720,
+        Narrowable = 133970943,
         NotUnionOrUnit = 67637251,
     }
     export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
@@ -2531,9 +2529,6 @@ declare namespace ts {
         baseType: Type;
         substitute: Type;
     }
-    export interface AwaitedType extends InstantiableType {
-        awaitedType: Type;
-    }
     export enum SignatureKind {
         Call = 0,
         Construct = 1
@@ -4075,7 +4070,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 | SyntaxKind.AwaitedKeyword, type: TypeNode): TypeOperatorNode;
+    function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, 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 7404ab2ce31b1..7fd9d53af7228 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 
         const obj = { ["a"]: () => this }; // computed property name after `await` triggers case
 >obj : { a: () => this; }
diff --git a/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt
index 13f43a5a168ae..ae57468b89407 100644
--- a/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction5_es2017.errors.txt
@@ -16,7 +16,7 @@ tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es20
 !!! error TS1005: ',' expected.
                              ~~~~~~~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'any'.
-!!! related TS6203 /.ts/lib.es2015.promise.d.ts:158:13: 'Promise' was also declared here.
+!!! related TS6203 /.ts/lib.es2015.promise.d.ts:150:13: 'Promise' was also declared here.
                                     ~
 !!! error TS1005: ',' expected.
                                            ~~
diff --git a/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt
index 8a6221ed8259d..ff87906ead394 100644
--- a/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction5_es5.errors.txt
@@ -16,7 +16,7 @@ tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts(
 !!! error TS1005: ',' expected.
                              ~~~~~~~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'any'.
-!!! related TS6203 /.ts/lib.es2015.promise.d.ts:158:13: 'Promise' was also declared here.
+!!! related TS6203 /.ts/lib.es2015.promise.d.ts:150:13: 'Promise' was also declared here.
                                     ~
 !!! error TS1005: ',' expected.
                                            ~~
diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt
index 02e755294bf90..b10782f083767 100644
--- a/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt
@@ -16,7 +16,7 @@ tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(
 !!! error TS1005: ',' expected.
                              ~~~~~~~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'any'.
-!!! related TS6203 /.ts/lib.es2015.promise.d.ts:158:13: 'Promise' was also declared here.
+!!! related TS6203 /.ts/lib.es2015.promise.d.ts:150:13: 'Promise' was also declared here.
                                     ~
 !!! error TS1005: ',' expected.
                                            ~~
diff --git a/tests/baselines/reference/asyncArrowFunction9_es2017.errors.txt b/tests/baselines/reference/asyncArrowFunction9_es2017.errors.txt
index 2bc2c3c50324b..ce7aaa8db1f8a 100644
--- a/tests/baselines/reference/asyncArrowFunction9_es2017.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction9_es2017.errors.txt
@@ -16,7 +16,7 @@ tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction9_es20
 !!! error TS1005: ',' expected.
                                           ~~~~~~~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'any'.
-!!! related TS6203 /.ts/lib.es2015.promise.d.ts:158:13: 'Promise' was also declared here.
+!!! related TS6203 /.ts/lib.es2015.promise.d.ts:150:13: 'Promise' was also declared here.
                                                  ~
 !!! error TS1005: ',' expected.
                                                         ~~
diff --git a/tests/baselines/reference/asyncArrowFunction9_es5.errors.txt b/tests/baselines/reference/asyncArrowFunction9_es5.errors.txt
index 4d2c3ebf49589..447b8c124f9cf 100644
--- a/tests/baselines/reference/asyncArrowFunction9_es5.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction9_es5.errors.txt
@@ -16,7 +16,7 @@ tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction9_es5.ts(
 !!! error TS1005: ',' expected.
                                           ~~~~~~~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'any'.
-!!! related TS6203 /.ts/lib.es2015.promise.d.ts:158:13: 'Promise' was also declared here.
+!!! related TS6203 /.ts/lib.es2015.promise.d.ts:150:13: 'Promise' was also declared here.
                                                  ~
 !!! error TS1005: ',' expected.
                                                         ~~
diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt
index f846db9523070..636d8e6e1c674 100644
--- a/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt
@@ -16,7 +16,7 @@ tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(
 !!! error TS1005: ',' expected.
                                           ~~~~~~~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'any'.
-!!! related TS6203 /.ts/lib.es2015.promise.d.ts:158:13: 'Promise' was also declared here.
+!!! related TS6203 /.ts/lib.es2015.promise.d.ts:150:13: 'Promise' was also declared here.
                                                  ~
 !!! error TS1005: ',' expected.
                                                         ~~
diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
index efb23e304fc50..7e3595ec6f4e0 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<awaited TResult1 | awaited TResult2>'.
+      Type 'void' is not assignable to type 'PromiseLike<TResult1 | 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<awaited TResult1 | awaited TResult2>'.
+!!! error TS1055:       Type 'void' is not assignable to type 'PromiseLike<TResult1 | TResult2>'.
     async function fn7() { return; } // valid: Promise<void>
     async function fn8() { return 1; } // valid: Promise<number>
     async function fn9() { return null; } // valid: Promise<any>
diff --git a/tests/baselines/reference/asyncFunctionReturnType.types b/tests/baselines/reference/asyncFunctionReturnType.types
index 8ee13111a38da..d2cb63e0a35f3 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >obj.stringProp : string
 >obj : TObj
 >stringProp : string
@@ -134,9 +134,9 @@ async function fGenericIndexedTypeForExplicitPromiseOfStringProp<TObj extends Ob
 
     return Promise.resolve<TObj["stringProp"]>(obj.stringProp);
 >Promise.resolve<TObj["stringProp"]>(obj.stringProp) : Promise<TObj["stringProp"]>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >obj.anyProp : any
 >obj : TObj
 >anyProp : any
@@ -171,10 +171,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
 >obj : TObj
 
     return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
->Promise.resolve<TObj["anyProp"]>(obj.anyProp) : Promise<awaited TObj["anyProp"]>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve<TObj["anyProp"]>(obj.anyProp) : Promise<TObj["anyProp"]>
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >obj.anyProp : any
 >obj : TObj
 >anyProp : any
@@ -197,10 +197,10 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
 >key : K
 
     return Promise.resolve(obj[key]);
->Promise.resolve(obj[key]) : Promise<awaited TObj[K]>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve(obj[key]) : Promise<TObj[K]>
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >obj[key] : TObj[K]
 >obj : TObj
 >key : K
@@ -212,10 +212,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
 >key : K
 
     return Promise.resolve<TObj[K]>(obj[key]);
->Promise.resolve<TObj[K]>(obj[key]) : Promise<awaited TObj[K]>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve<TObj[K]>(obj[key]) : Promise<TObj[K]>
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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
deleted file mode 100644
index 838d3e3b9e00d..0000000000000
--- a/tests/baselines/reference/awaited.js
+++ /dev/null
@@ -1,209 +0,0 @@
-//// [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 V | awaited U>;
-declare function f5<U>(u: Promise<U>): Promise<U>;
-declare function f6<U>(u: Promise<Promise<U>>): Promise<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
deleted file mode 100644
index d8af632541f4f..0000000000000
--- a/tests/baselines/reference/awaited.symbols
+++ /dev/null
@@ -1,406 +0,0 @@
-=== 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
deleted file mode 100644
index 790e209a80a0f..0000000000000
--- a/tests/baselines/reference/awaited.types
+++ /dev/null
@@ -1,499 +0,0 @@
-=== 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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
->p0 : Promise<number>
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
->p1 : Promise<Promise<number>>
->then : <TResult1 = Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
->p2 : Promise<number | Promise<number>>
->then : <TResult1 = number | Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult>) => Promise<awaited TResult | awaited U>
->makePromise(u) : Promise<U>
->makePromise : <T>(x: T) => Promise<T>
->u : U
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<awaited TResult | awaited U>
->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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 V | awaited U>
->u : U
->v : V
-
-    return makePromise(u).catch(x => {
->makePromise(u).catch(x => {        if (f) return v;        return Promise.reject("b");    }) : Promise<awaited V | awaited U>
->makePromise(u).catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<awaited TResult | awaited U>
->makePromise(u) : Promise<U>
->makePromise : <T>(x: T) => Promise<T>
->u : U
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<awaited TResult | awaited U>
->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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
->f4(1, "a") : Promise<string | number>
->f4 : <U, V>(u: U, v: V) => Promise<awaited V | awaited U>
->1 : 1
->"a" : "a"
->then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
->f4(makePromise(1), makePromise("a")) : Promise<string | number>
->f4 : <U, V>(u: U, v: V) => Promise<awaited V | awaited U>
->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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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<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 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
->f5(makePromise(1)) : Promise<number>
->f5 : <U>(u: Promise<U>) => Promise<U>
->makePromise(1) : Promise<number>
->makePromise : <T>(x: T) => Promise<T>
->1 : 1
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 = Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
->f5(makePromise(makePromise(1))) : Promise<Promise<number>>
->f5 : <U>(u: Promise<U>) => Promise<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 = Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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<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/awaitedInference.js b/tests/baselines/reference/awaitedInference.js
deleted file mode 100644
index 8c2fe01afb252..0000000000000
--- a/tests/baselines/reference/awaitedInference.js
+++ /dev/null
@@ -1,64 +0,0 @@
-//// [awaitedInference.ts]
-declare function foo<T>(f: () => PromiseLike<T>, x: T): void;
-declare const nullOrNumber: number | null;
-foo(async () => nullOrNumber, null);
-
-type UnwrapAwaited<T> = T extends awaited infer Inner ? Inner : T;
-type Result1 = UnwrapAwaited<awaited Promise<number>>; // number
-type Result2 = UnwrapAwaited<awaited Promise<number> | number>; // number
-function f<T>() {
-    type Result1 = UnwrapAwaited<T>; // UnwrapAwaited<T>
-    type Result2 = UnwrapAwaited<awaited T>; // UnwrapAwaited<awaited T>
-    return null as any as [Result1, Result2];
-}
-const x = f<number>(); // number
-const y = f<Promise<number>>(); // number ?
-const z = f<Promise<number> | number>(); // number ?
-
-//// [awaitedInference.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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var _this = this;
-foo(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-    return [2 /*return*/, nullOrNumber];
-}); }); }, null);
-function f() {
-    return null;
-}
-var x = f(); // number
-var y = f(); // number ?
-var z = f(); // number ?
diff --git a/tests/baselines/reference/awaitedInference.symbols b/tests/baselines/reference/awaitedInference.symbols
deleted file mode 100644
index 82afccc34742f..0000000000000
--- a/tests/baselines/reference/awaitedInference.symbols
+++ /dev/null
@@ -1,67 +0,0 @@
-=== tests/cases/conformance/types/awaited/awaitedInference.ts ===
-declare function foo<T>(f: () => PromiseLike<T>, x: T): void;
->foo : Symbol(foo, Decl(awaitedInference.ts, 0, 0))
->T : Symbol(T, Decl(awaitedInference.ts, 0, 21))
->f : Symbol(f, Decl(awaitedInference.ts, 0, 24))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
->T : Symbol(T, Decl(awaitedInference.ts, 0, 21))
->x : Symbol(x, Decl(awaitedInference.ts, 0, 48))
->T : Symbol(T, Decl(awaitedInference.ts, 0, 21))
-
-declare const nullOrNumber: number | null;
->nullOrNumber : Symbol(nullOrNumber, Decl(awaitedInference.ts, 1, 13))
-
-foo(async () => nullOrNumber, null);
->foo : Symbol(foo, Decl(awaitedInference.ts, 0, 0))
->nullOrNumber : Symbol(nullOrNumber, Decl(awaitedInference.ts, 1, 13))
-
-type UnwrapAwaited<T> = T extends awaited infer Inner ? Inner : T;
->UnwrapAwaited : Symbol(UnwrapAwaited, Decl(awaitedInference.ts, 2, 36))
->T : Symbol(T, Decl(awaitedInference.ts, 4, 19))
->T : Symbol(T, Decl(awaitedInference.ts, 4, 19))
->Inner : Symbol(Inner, Decl(awaitedInference.ts, 4, 47))
->Inner : Symbol(Inner, Decl(awaitedInference.ts, 4, 47))
->T : Symbol(T, Decl(awaitedInference.ts, 4, 19))
-
-type Result1 = UnwrapAwaited<awaited Promise<number>>; // number
->Result1 : Symbol(Result1, Decl(awaitedInference.ts, 4, 66))
->UnwrapAwaited : Symbol(UnwrapAwaited, Decl(awaitedInference.ts, 2, 36))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --))
-
-type Result2 = UnwrapAwaited<awaited Promise<number> | number>; // number
->Result2 : Symbol(Result2, Decl(awaitedInference.ts, 5, 54))
->UnwrapAwaited : Symbol(UnwrapAwaited, Decl(awaitedInference.ts, 2, 36))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --))
-
-function f<T>() {
->f : Symbol(f, Decl(awaitedInference.ts, 6, 63))
->T : Symbol(T, Decl(awaitedInference.ts, 7, 11))
-
-    type Result1 = UnwrapAwaited<T>; // UnwrapAwaited<T>
->Result1 : Symbol(Result1, Decl(awaitedInference.ts, 7, 17))
->UnwrapAwaited : Symbol(UnwrapAwaited, Decl(awaitedInference.ts, 2, 36))
->T : Symbol(T, Decl(awaitedInference.ts, 7, 11))
-
-    type Result2 = UnwrapAwaited<awaited T>; // UnwrapAwaited<awaited T>
->Result2 : Symbol(Result2, Decl(awaitedInference.ts, 8, 36))
->UnwrapAwaited : Symbol(UnwrapAwaited, Decl(awaitedInference.ts, 2, 36))
->T : Symbol(T, Decl(awaitedInference.ts, 7, 11))
-
-    return null as any as [Result1, Result2];
->Result1 : Symbol(Result1, Decl(awaitedInference.ts, 7, 17))
->Result2 : Symbol(Result2, Decl(awaitedInference.ts, 8, 36))
-}
-const x = f<number>(); // number
->x : Symbol(x, Decl(awaitedInference.ts, 12, 5))
->f : Symbol(f, Decl(awaitedInference.ts, 6, 63))
-
-const y = f<Promise<number>>(); // number ?
->y : Symbol(y, Decl(awaitedInference.ts, 13, 5))
->f : Symbol(f, Decl(awaitedInference.ts, 6, 63))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --))
-
-const z = f<Promise<number> | number>(); // number ?
->z : Symbol(z, Decl(awaitedInference.ts, 14, 5))
->f : Symbol(f, Decl(awaitedInference.ts, 6, 63))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --))
-
diff --git a/tests/baselines/reference/awaitedInference.types b/tests/baselines/reference/awaitedInference.types
deleted file mode 100644
index 91e7c43134e94..0000000000000
--- a/tests/baselines/reference/awaitedInference.types
+++ /dev/null
@@ -1,55 +0,0 @@
-=== tests/cases/conformance/types/awaited/awaitedInference.ts ===
-declare function foo<T>(f: () => PromiseLike<T>, x: T): void;
->foo : <T>(f: () => PromiseLike<T>, x: T) => void
->f : () => PromiseLike<T>
->x : T
-
-declare const nullOrNumber: number | null;
->nullOrNumber : number
->null : null
-
-foo(async () => nullOrNumber, null);
->foo(async () => nullOrNumber, null) : void
->foo : <T>(f: () => PromiseLike<T>, x: T) => void
->async () => nullOrNumber : () => Promise<number>
->nullOrNumber : number
->null : null
-
-type UnwrapAwaited<T> = T extends awaited infer Inner ? Inner : T;
->UnwrapAwaited : UnwrapAwaited<T>
-
-type Result1 = UnwrapAwaited<awaited Promise<number>>; // number
->Result1 : number
-
-type Result2 = UnwrapAwaited<awaited Promise<number> | number>; // number
->Result2 : number
-
-function f<T>() {
->f : <T>() => [UnwrapAwaited<T>, UnwrapAwaited<awaited T>]
-
-    type Result1 = UnwrapAwaited<T>; // UnwrapAwaited<T>
->Result1 : UnwrapAwaited<T>
-
-    type Result2 = UnwrapAwaited<awaited T>; // UnwrapAwaited<awaited T>
->Result2 : UnwrapAwaited<awaited T>
-
-    return null as any as [Result1, Result2];
->null as any as [Result1, Result2] : [UnwrapAwaited<T>, UnwrapAwaited<awaited T>]
->null as any : any
->null : null
-}
-const x = f<number>(); // number
->x : [number, number]
->f<number>() : [number, number]
->f : <T>() => [UnwrapAwaited<T>, UnwrapAwaited<awaited T>]
-
-const y = f<Promise<number>>(); // number ?
->y : [Promise<number>, number]
->f<Promise<number>>() : [Promise<number>, number]
->f : <T>() => [UnwrapAwaited<T>, UnwrapAwaited<awaited T>]
-
-const z = f<Promise<number> | number>(); // number ?
->z : [number | Promise<number>, number]
->f<Promise<number> | number>() : [number | Promise<number>, number]
->f : <T>() => [UnwrapAwaited<T>, UnwrapAwaited<awaited T>]
-
diff --git a/tests/baselines/reference/awaitedVariance.errors.txt b/tests/baselines/reference/awaitedVariance.errors.txt
deleted file mode 100644
index 694ca4c62f96a..0000000000000
--- a/tests/baselines/reference/awaitedVariance.errors.txt
+++ /dev/null
@@ -1,140 +0,0 @@
-tests/cases/conformance/types/awaited/awaitedVariance.ts(74,1): error TS2322: Type 'C<Promise<number>>' is not assignable to type 'C<number>'.
-  Types of property 'x' are incompatible.
-    Type 'number' is not assignable to type '{ _tag: string; } & number'.
-      Type 'number' is not assignable to type '{ _tag: string; }'.
-tests/cases/conformance/types/awaited/awaitedVariance.ts(84,1): error TS2322: Type 'D<Promise<number>>' is not assignable to type 'D<number>'.
-  Types of property 'a' are incompatible.
-    Type 'C<Promise<number>>' is not assignable to type 'C<number>'.
-
-
-==== tests/cases/conformance/types/awaited/awaitedVariance.ts (2 errors) ====
-    declare let p0: Promise<number>;
-    declare let p1: Promise<Promise<number>>;
-    declare let p2: Promise<awaited number>;
-    p0 = p1;
-    p0 = p2;
-    p1 = p0;
-    p1 = p2;
-    p2 = p0;
-    p2 = p1;
-    
-    function fn1<T>(p0: Promise<T>, p1: Promise<Promise<T>>, p2: Promise<awaited T>) {
-        p0 = p1;
-        p0 = p2;
-        p1 = p0;
-        p1 = p2;
-        p2 = p0;
-        p2 = p1;
-    }
-    
-    declare let pl0: PromiseLike<number>;
-    declare let pl1: PromiseLike<PromiseLike<number>>;
-    declare let pl2: PromiseLike<awaited number>;
-    pl0 = pl1;
-    pl0 = pl2;
-    pl1 = pl0;
-    pl1 = pl2;
-    pl2 = pl0;
-    pl2 = pl1;
-    
-    function fn2<T>(pl0: PromiseLike<T>, pl1: PromiseLike<PromiseLike<T>>, pl2: PromiseLike<awaited T>) {
-        pl0 = pl1;
-        pl0 = pl2;
-        pl1 = pl0;
-        pl1 = pl2;
-        pl2 = pl0;
-        pl2 = pl1;
-    }
-    
-    pl0 = p0;
-    pl0 = p1;
-    pl0 = p2;
-    pl1 = p0;
-    pl1 = p1;
-    pl1 = p2;
-    pl2 = p0;
-    pl2 = p1;
-    pl2 = p2;
-    
-    interface A<T> {
-        x: awaited T;
-    }
-    
-    declare let a1: A<number>;
-    declare let a2: A<Promise<number>>;
-    a1 = a2;
-    a2 = a1;
-    
-    interface B<T> {
-        a: A<T>;
-    }
-    
-    declare let b1: B<number>;
-    declare let b2: B<Promise<number>>;
-    b1 = b2;
-    b2 = b1;
-    
-    interface C<T> {
-        x: awaited ({_tag: string} & T);
-    }
-    
-    declare let c1: C<number>;
-    declare let c2: C<Promise<number>>;
-    // Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-    c1 = c2;
-    ~~
-!!! error TS2322: Type 'C<Promise<number>>' is not assignable to type 'C<number>'.
-!!! error TS2322:   Types of property 'x' are incompatible.
-!!! error TS2322:     Type 'number' is not assignable to type '{ _tag: string; } & number'.
-!!! error TS2322:       Type 'number' is not assignable to type '{ _tag: string; }'.
-    c2 = c1;
-    
-    interface D<T> {
-        a: C<T>;
-    }
-    
-    declare let d1: D<number>;
-    declare let d2: D<Promise<number>>;
-    // Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-    d1 = d2;
-    ~~
-!!! error TS2322: Type 'D<Promise<number>>' is not assignable to type 'D<number>'.
-!!! error TS2322:   Types of property 'a' are incompatible.
-!!! error TS2322:     Type 'C<Promise<number>>' is not assignable to type 'C<number>'.
-    d2 = d1;
-    
-    interface E<T> {
-        x: awaited (T | {otherOption: string});
-    }
-    
-    declare let e1: E<number>;
-    declare let e2: E<Promise<number>>;
-    e1 = e2;
-    e2 = e1;
-    
-    interface F<T> {
-        a: E<T>;
-    }
-    
-    declare let f1: F<number>;
-    declare let f2: F<Promise<number>>;
-    f1 = f2;
-    f2 = f1;
-    
-    interface G<T, K extends keyof T> {
-        x: awaited T[K];
-    }
-    
-    declare let g1: G<{x: number}, "x">;
-    declare let g2: G<{x: Promise<number>}, "x">;
-    g1 = g2;
-    g2 = g1;
-    
-    interface H<T, K extends keyof T> {
-        a: G<T, K>;
-    }
-    
-    declare let h1: H<{x: number}, "x">;
-    declare let h2: H<{x: Promise<number>}, "x">;
-    h1 = h2;
-    h2 = h1;
\ No newline at end of file
diff --git a/tests/baselines/reference/awaitedVariance.js b/tests/baselines/reference/awaitedVariance.js
deleted file mode 100644
index 1edaf909e67b2..0000000000000
--- a/tests/baselines/reference/awaitedVariance.js
+++ /dev/null
@@ -1,179 +0,0 @@
-//// [awaitedVariance.ts]
-declare let p0: Promise<number>;
-declare let p1: Promise<Promise<number>>;
-declare let p2: Promise<awaited number>;
-p0 = p1;
-p0 = p2;
-p1 = p0;
-p1 = p2;
-p2 = p0;
-p2 = p1;
-
-function fn1<T>(p0: Promise<T>, p1: Promise<Promise<T>>, p2: Promise<awaited T>) {
-    p0 = p1;
-    p0 = p2;
-    p1 = p0;
-    p1 = p2;
-    p2 = p0;
-    p2 = p1;
-}
-
-declare let pl0: PromiseLike<number>;
-declare let pl1: PromiseLike<PromiseLike<number>>;
-declare let pl2: PromiseLike<awaited number>;
-pl0 = pl1;
-pl0 = pl2;
-pl1 = pl0;
-pl1 = pl2;
-pl2 = pl0;
-pl2 = pl1;
-
-function fn2<T>(pl0: PromiseLike<T>, pl1: PromiseLike<PromiseLike<T>>, pl2: PromiseLike<awaited T>) {
-    pl0 = pl1;
-    pl0 = pl2;
-    pl1 = pl0;
-    pl1 = pl2;
-    pl2 = pl0;
-    pl2 = pl1;
-}
-
-pl0 = p0;
-pl0 = p1;
-pl0 = p2;
-pl1 = p0;
-pl1 = p1;
-pl1 = p2;
-pl2 = p0;
-pl2 = p1;
-pl2 = p2;
-
-interface A<T> {
-    x: awaited T;
-}
-
-declare let a1: A<number>;
-declare let a2: A<Promise<number>>;
-a1 = a2;
-a2 = a1;
-
-interface B<T> {
-    a: A<T>;
-}
-
-declare let b1: B<number>;
-declare let b2: B<Promise<number>>;
-b1 = b2;
-b2 = b1;
-
-interface C<T> {
-    x: awaited ({_tag: string} & T);
-}
-
-declare let c1: C<number>;
-declare let c2: C<Promise<number>>;
-// Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-c1 = c2;
-c2 = c1;
-
-interface D<T> {
-    a: C<T>;
-}
-
-declare let d1: D<number>;
-declare let d2: D<Promise<number>>;
-// Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-d1 = d2;
-d2 = d1;
-
-interface E<T> {
-    x: awaited (T | {otherOption: string});
-}
-
-declare let e1: E<number>;
-declare let e2: E<Promise<number>>;
-e1 = e2;
-e2 = e1;
-
-interface F<T> {
-    a: E<T>;
-}
-
-declare let f1: F<number>;
-declare let f2: F<Promise<number>>;
-f1 = f2;
-f2 = f1;
-
-interface G<T, K extends keyof T> {
-    x: awaited T[K];
-}
-
-declare let g1: G<{x: number}, "x">;
-declare let g2: G<{x: Promise<number>}, "x">;
-g1 = g2;
-g2 = g1;
-
-interface H<T, K extends keyof T> {
-    a: G<T, K>;
-}
-
-declare let h1: H<{x: number}, "x">;
-declare let h2: H<{x: Promise<number>}, "x">;
-h1 = h2;
-h2 = h1;
-
-//// [awaitedVariance.js]
-p0 = p1;
-p0 = p2;
-p1 = p0;
-p1 = p2;
-p2 = p0;
-p2 = p1;
-function fn1(p0, p1, p2) {
-    p0 = p1;
-    p0 = p2;
-    p1 = p0;
-    p1 = p2;
-    p2 = p0;
-    p2 = p1;
-}
-pl0 = pl1;
-pl0 = pl2;
-pl1 = pl0;
-pl1 = pl2;
-pl2 = pl0;
-pl2 = pl1;
-function fn2(pl0, pl1, pl2) {
-    pl0 = pl1;
-    pl0 = pl2;
-    pl1 = pl0;
-    pl1 = pl2;
-    pl2 = pl0;
-    pl2 = pl1;
-}
-pl0 = p0;
-pl0 = p1;
-pl0 = p2;
-pl1 = p0;
-pl1 = p1;
-pl1 = p2;
-pl2 = p0;
-pl2 = p1;
-pl2 = p2;
-a1 = a2;
-a2 = a1;
-b1 = b2;
-b2 = b1;
-// Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-c1 = c2;
-c2 = c1;
-// Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-d1 = d2;
-d2 = d1;
-e1 = e2;
-e2 = e1;
-f1 = f2;
-f2 = f1;
-g1 = g2;
-g2 = g1;
-h1 = h2;
-h2 = h1;
diff --git a/tests/baselines/reference/awaitedVariance.symbols b/tests/baselines/reference/awaitedVariance.symbols
deleted file mode 100644
index 521dc557ad0e3..0000000000000
--- a/tests/baselines/reference/awaitedVariance.symbols
+++ /dev/null
@@ -1,415 +0,0 @@
-=== tests/cases/conformance/types/awaited/awaitedVariance.ts ===
-declare let p0: Promise<number>;
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 0, 11))
->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, --, --))
-
-declare let p1: Promise<Promise<number>>;
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 1, 11))
->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, --, --))
-
-declare let p2: Promise<awaited number>;
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 2, 11))
->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 = p1;
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 0, 11))
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 1, 11))
-
-p0 = p2;
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 0, 11))
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 2, 11))
-
-p1 = p0;
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 1, 11))
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 0, 11))
-
-p1 = p2;
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 1, 11))
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 2, 11))
-
-p2 = p0;
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 2, 11))
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 0, 11))
-
-p2 = p1;
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 2, 11))
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 1, 11))
-
-function fn1<T>(p0: Promise<T>, p1: Promise<Promise<T>>, p2: Promise<awaited T>) {
->fn1 : Symbol(fn1, Decl(awaitedVariance.ts, 8, 8))
->T : Symbol(T, Decl(awaitedVariance.ts, 10, 13))
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 10, 16))
->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(awaitedVariance.ts, 10, 13))
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 10, 31))
->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, --, --))
->T : Symbol(T, Decl(awaitedVariance.ts, 10, 13))
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 10, 56))
->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(awaitedVariance.ts, 10, 13))
-
-    p0 = p1;
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 10, 16))
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 10, 31))
-
-    p0 = p2;
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 10, 16))
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 10, 56))
-
-    p1 = p0;
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 10, 31))
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 10, 16))
-
-    p1 = p2;
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 10, 31))
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 10, 56))
-
-    p2 = p0;
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 10, 56))
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 10, 16))
-
-    p2 = p1;
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 10, 56))
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 10, 31))
-}
-
-declare let pl0: PromiseLike<number>;
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 19, 11))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
-
-declare let pl1: PromiseLike<PromiseLike<number>>;
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 20, 11))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
-
-declare let pl2: PromiseLike<awaited number>;
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 21, 11))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
-
-pl0 = pl1;
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 19, 11))
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 20, 11))
-
-pl0 = pl2;
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 19, 11))
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 21, 11))
-
-pl1 = pl0;
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 20, 11))
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 19, 11))
-
-pl1 = pl2;
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 20, 11))
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 21, 11))
-
-pl2 = pl0;
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 21, 11))
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 19, 11))
-
-pl2 = pl1;
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 21, 11))
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 20, 11))
-
-function fn2<T>(pl0: PromiseLike<T>, pl1: PromiseLike<PromiseLike<T>>, pl2: PromiseLike<awaited T>) {
->fn2 : Symbol(fn2, Decl(awaitedVariance.ts, 27, 10))
->T : Symbol(T, Decl(awaitedVariance.ts, 29, 13))
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 29, 16))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
->T : Symbol(T, Decl(awaitedVariance.ts, 29, 13))
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 29, 36))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
->T : Symbol(T, Decl(awaitedVariance.ts, 29, 13))
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 29, 70))
->PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --))
->T : Symbol(T, Decl(awaitedVariance.ts, 29, 13))
-
-    pl0 = pl1;
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 29, 16))
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 29, 36))
-
-    pl0 = pl2;
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 29, 16))
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 29, 70))
-
-    pl1 = pl0;
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 29, 36))
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 29, 16))
-
-    pl1 = pl2;
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 29, 36))
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 29, 70))
-
-    pl2 = pl0;
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 29, 70))
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 29, 16))
-
-    pl2 = pl1;
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 29, 70))
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 29, 36))
-}
-
-pl0 = p0;
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 19, 11))
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 0, 11))
-
-pl0 = p1;
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 19, 11))
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 1, 11))
-
-pl0 = p2;
->pl0 : Symbol(pl0, Decl(awaitedVariance.ts, 19, 11))
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 2, 11))
-
-pl1 = p0;
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 20, 11))
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 0, 11))
-
-pl1 = p1;
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 20, 11))
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 1, 11))
-
-pl1 = p2;
->pl1 : Symbol(pl1, Decl(awaitedVariance.ts, 20, 11))
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 2, 11))
-
-pl2 = p0;
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 21, 11))
->p0 : Symbol(p0, Decl(awaitedVariance.ts, 0, 11))
-
-pl2 = p1;
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 21, 11))
->p1 : Symbol(p1, Decl(awaitedVariance.ts, 1, 11))
-
-pl2 = p2;
->pl2 : Symbol(pl2, Decl(awaitedVariance.ts, 21, 11))
->p2 : Symbol(p2, Decl(awaitedVariance.ts, 2, 11))
-
-interface A<T> {
->A : Symbol(A, Decl(awaitedVariance.ts, 46, 9))
->T : Symbol(T, Decl(awaitedVariance.ts, 48, 12))
-
-    x: awaited T;
->x : Symbol(A.x, Decl(awaitedVariance.ts, 48, 16))
->T : Symbol(T, Decl(awaitedVariance.ts, 48, 12))
-}
-
-declare let a1: A<number>;
->a1 : Symbol(a1, Decl(awaitedVariance.ts, 52, 11))
->A : Symbol(A, Decl(awaitedVariance.ts, 46, 9))
-
-declare let a2: A<Promise<number>>;
->a2 : Symbol(a2, Decl(awaitedVariance.ts, 53, 11))
->A : Symbol(A, Decl(awaitedVariance.ts, 46, 9))
->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, --, --))
-
-a1 = a2;
->a1 : Symbol(a1, Decl(awaitedVariance.ts, 52, 11))
->a2 : Symbol(a2, Decl(awaitedVariance.ts, 53, 11))
-
-a2 = a1;
->a2 : Symbol(a2, Decl(awaitedVariance.ts, 53, 11))
->a1 : Symbol(a1, Decl(awaitedVariance.ts, 52, 11))
-
-interface B<T> {
->B : Symbol(B, Decl(awaitedVariance.ts, 55, 8))
->T : Symbol(T, Decl(awaitedVariance.ts, 57, 12))
-
-    a: A<T>;
->a : Symbol(B.a, Decl(awaitedVariance.ts, 57, 16))
->A : Symbol(A, Decl(awaitedVariance.ts, 46, 9))
->T : Symbol(T, Decl(awaitedVariance.ts, 57, 12))
-}
-
-declare let b1: B<number>;
->b1 : Symbol(b1, Decl(awaitedVariance.ts, 61, 11))
->B : Symbol(B, Decl(awaitedVariance.ts, 55, 8))
-
-declare let b2: B<Promise<number>>;
->b2 : Symbol(b2, Decl(awaitedVariance.ts, 62, 11))
->B : Symbol(B, Decl(awaitedVariance.ts, 55, 8))
->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, --, --))
-
-b1 = b2;
->b1 : Symbol(b1, Decl(awaitedVariance.ts, 61, 11))
->b2 : Symbol(b2, Decl(awaitedVariance.ts, 62, 11))
-
-b2 = b1;
->b2 : Symbol(b2, Decl(awaitedVariance.ts, 62, 11))
->b1 : Symbol(b1, Decl(awaitedVariance.ts, 61, 11))
-
-interface C<T> {
->C : Symbol(C, Decl(awaitedVariance.ts, 64, 8))
->T : Symbol(T, Decl(awaitedVariance.ts, 66, 12))
-
-    x: awaited ({_tag: string} & T);
->x : Symbol(C.x, Decl(awaitedVariance.ts, 66, 16))
->_tag : Symbol(_tag, Decl(awaitedVariance.ts, 67, 17))
->T : Symbol(T, Decl(awaitedVariance.ts, 66, 12))
-}
-
-declare let c1: C<number>;
->c1 : Symbol(c1, Decl(awaitedVariance.ts, 70, 11))
->C : Symbol(C, Decl(awaitedVariance.ts, 64, 8))
-
-declare let c2: C<Promise<number>>;
->c2 : Symbol(c2, Decl(awaitedVariance.ts, 71, 11))
->C : Symbol(C, Decl(awaitedVariance.ts, 64, 8))
->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, --, --))
-
-// Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-c1 = c2;
->c1 : Symbol(c1, Decl(awaitedVariance.ts, 70, 11))
->c2 : Symbol(c2, Decl(awaitedVariance.ts, 71, 11))
-
-c2 = c1;
->c2 : Symbol(c2, Decl(awaitedVariance.ts, 71, 11))
->c1 : Symbol(c1, Decl(awaitedVariance.ts, 70, 11))
-
-interface D<T> {
->D : Symbol(D, Decl(awaitedVariance.ts, 74, 8))
->T : Symbol(T, Decl(awaitedVariance.ts, 76, 12))
-
-    a: C<T>;
->a : Symbol(D.a, Decl(awaitedVariance.ts, 76, 16))
->C : Symbol(C, Decl(awaitedVariance.ts, 64, 8))
->T : Symbol(T, Decl(awaitedVariance.ts, 76, 12))
-}
-
-declare let d1: D<number>;
->d1 : Symbol(d1, Decl(awaitedVariance.ts, 80, 11))
->D : Symbol(D, Decl(awaitedVariance.ts, 74, 8))
-
-declare let d2: D<Promise<number>>;
->d2 : Symbol(d2, Decl(awaitedVariance.ts, 81, 11))
->D : Symbol(D, Decl(awaitedVariance.ts, 74, 8))
->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, --, --))
-
-// Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-d1 = d2;
->d1 : Symbol(d1, Decl(awaitedVariance.ts, 80, 11))
->d2 : Symbol(d2, Decl(awaitedVariance.ts, 81, 11))
-
-d2 = d1;
->d2 : Symbol(d2, Decl(awaitedVariance.ts, 81, 11))
->d1 : Symbol(d1, Decl(awaitedVariance.ts, 80, 11))
-
-interface E<T> {
->E : Symbol(E, Decl(awaitedVariance.ts, 84, 8))
->T : Symbol(T, Decl(awaitedVariance.ts, 86, 12))
-
-    x: awaited (T | {otherOption: string});
->x : Symbol(E.x, Decl(awaitedVariance.ts, 86, 16))
->T : Symbol(T, Decl(awaitedVariance.ts, 86, 12))
->otherOption : Symbol(otherOption, Decl(awaitedVariance.ts, 87, 21))
-}
-
-declare let e1: E<number>;
->e1 : Symbol(e1, Decl(awaitedVariance.ts, 90, 11))
->E : Symbol(E, Decl(awaitedVariance.ts, 84, 8))
-
-declare let e2: E<Promise<number>>;
->e2 : Symbol(e2, Decl(awaitedVariance.ts, 91, 11))
->E : Symbol(E, Decl(awaitedVariance.ts, 84, 8))
->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, --, --))
-
-e1 = e2;
->e1 : Symbol(e1, Decl(awaitedVariance.ts, 90, 11))
->e2 : Symbol(e2, Decl(awaitedVariance.ts, 91, 11))
-
-e2 = e1;
->e2 : Symbol(e2, Decl(awaitedVariance.ts, 91, 11))
->e1 : Symbol(e1, Decl(awaitedVariance.ts, 90, 11))
-
-interface F<T> {
->F : Symbol(F, Decl(awaitedVariance.ts, 93, 8))
->T : Symbol(T, Decl(awaitedVariance.ts, 95, 12))
-
-    a: E<T>;
->a : Symbol(F.a, Decl(awaitedVariance.ts, 95, 16))
->E : Symbol(E, Decl(awaitedVariance.ts, 84, 8))
->T : Symbol(T, Decl(awaitedVariance.ts, 95, 12))
-}
-
-declare let f1: F<number>;
->f1 : Symbol(f1, Decl(awaitedVariance.ts, 99, 11))
->F : Symbol(F, Decl(awaitedVariance.ts, 93, 8))
-
-declare let f2: F<Promise<number>>;
->f2 : Symbol(f2, Decl(awaitedVariance.ts, 100, 11))
->F : Symbol(F, Decl(awaitedVariance.ts, 93, 8))
->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, --, --))
-
-f1 = f2;
->f1 : Symbol(f1, Decl(awaitedVariance.ts, 99, 11))
->f2 : Symbol(f2, Decl(awaitedVariance.ts, 100, 11))
-
-f2 = f1;
->f2 : Symbol(f2, Decl(awaitedVariance.ts, 100, 11))
->f1 : Symbol(f1, Decl(awaitedVariance.ts, 99, 11))
-
-interface G<T, K extends keyof T> {
->G : Symbol(G, Decl(awaitedVariance.ts, 102, 8))
->T : Symbol(T, Decl(awaitedVariance.ts, 104, 12))
->K : Symbol(K, Decl(awaitedVariance.ts, 104, 14))
->T : Symbol(T, Decl(awaitedVariance.ts, 104, 12))
-
-    x: awaited T[K];
->x : Symbol(G.x, Decl(awaitedVariance.ts, 104, 35))
->T : Symbol(T, Decl(awaitedVariance.ts, 104, 12))
->K : Symbol(K, Decl(awaitedVariance.ts, 104, 14))
-}
-
-declare let g1: G<{x: number}, "x">;
->g1 : Symbol(g1, Decl(awaitedVariance.ts, 108, 11))
->G : Symbol(G, Decl(awaitedVariance.ts, 102, 8))
->x : Symbol(x, Decl(awaitedVariance.ts, 108, 19))
-
-declare let g2: G<{x: Promise<number>}, "x">;
->g2 : Symbol(g2, Decl(awaitedVariance.ts, 109, 11))
->G : Symbol(G, Decl(awaitedVariance.ts, 102, 8))
->x : Symbol(x, Decl(awaitedVariance.ts, 109, 19))
->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, --, --))
-
-g1 = g2;
->g1 : Symbol(g1, Decl(awaitedVariance.ts, 108, 11))
->g2 : Symbol(g2, Decl(awaitedVariance.ts, 109, 11))
-
-g2 = g1;
->g2 : Symbol(g2, Decl(awaitedVariance.ts, 109, 11))
->g1 : Symbol(g1, Decl(awaitedVariance.ts, 108, 11))
-
-interface H<T, K extends keyof T> {
->H : Symbol(H, Decl(awaitedVariance.ts, 111, 8))
->T : Symbol(T, Decl(awaitedVariance.ts, 113, 12))
->K : Symbol(K, Decl(awaitedVariance.ts, 113, 14))
->T : Symbol(T, Decl(awaitedVariance.ts, 113, 12))
-
-    a: G<T, K>;
->a : Symbol(H.a, Decl(awaitedVariance.ts, 113, 35))
->G : Symbol(G, Decl(awaitedVariance.ts, 102, 8))
->T : Symbol(T, Decl(awaitedVariance.ts, 113, 12))
->K : Symbol(K, Decl(awaitedVariance.ts, 113, 14))
-}
-
-declare let h1: H<{x: number}, "x">;
->h1 : Symbol(h1, Decl(awaitedVariance.ts, 117, 11))
->H : Symbol(H, Decl(awaitedVariance.ts, 111, 8))
->x : Symbol(x, Decl(awaitedVariance.ts, 117, 19))
-
-declare let h2: H<{x: Promise<number>}, "x">;
->h2 : Symbol(h2, Decl(awaitedVariance.ts, 118, 11))
->H : Symbol(H, Decl(awaitedVariance.ts, 111, 8))
->x : Symbol(x, Decl(awaitedVariance.ts, 118, 19))
->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, --, --))
-
-h1 = h2;
->h1 : Symbol(h1, Decl(awaitedVariance.ts, 117, 11))
->h2 : Symbol(h2, Decl(awaitedVariance.ts, 118, 11))
-
-h2 = h1;
->h2 : Symbol(h2, Decl(awaitedVariance.ts, 118, 11))
->h1 : Symbol(h1, Decl(awaitedVariance.ts, 117, 11))
-
diff --git a/tests/baselines/reference/awaitedVariance.types b/tests/baselines/reference/awaitedVariance.types
deleted file mode 100644
index a063fb380caa0..0000000000000
--- a/tests/baselines/reference/awaitedVariance.types
+++ /dev/null
@@ -1,374 +0,0 @@
-=== tests/cases/conformance/types/awaited/awaitedVariance.ts ===
-declare let p0: Promise<number>;
->p0 : Promise<number>
-
-declare let p1: Promise<Promise<number>>;
->p1 : Promise<Promise<number>>
-
-declare let p2: Promise<awaited number>;
->p2 : Promise<number>
-
-p0 = p1;
->p0 = p1 : Promise<Promise<number>>
->p0 : Promise<number>
->p1 : Promise<Promise<number>>
-
-p0 = p2;
->p0 = p2 : Promise<number>
->p0 : Promise<number>
->p2 : Promise<number>
-
-p1 = p0;
->p1 = p0 : Promise<number>
->p1 : Promise<Promise<number>>
->p0 : Promise<number>
-
-p1 = p2;
->p1 = p2 : Promise<number>
->p1 : Promise<Promise<number>>
->p2 : Promise<number>
-
-p2 = p0;
->p2 = p0 : Promise<number>
->p2 : Promise<number>
->p0 : Promise<number>
-
-p2 = p1;
->p2 = p1 : Promise<Promise<number>>
->p2 : Promise<number>
->p1 : Promise<Promise<number>>
-
-function fn1<T>(p0: Promise<T>, p1: Promise<Promise<T>>, p2: Promise<awaited T>) {
->fn1 : <T>(p0: Promise<T>, p1: Promise<Promise<T>>, p2: Promise<awaited T>) => void
->p0 : Promise<T>
->p1 : Promise<Promise<T>>
->p2 : Promise<awaited T>
-
-    p0 = p1;
->p0 = p1 : Promise<Promise<T>>
->p0 : Promise<T>
->p1 : Promise<Promise<T>>
-
-    p0 = p2;
->p0 = p2 : Promise<awaited T>
->p0 : Promise<T>
->p2 : Promise<awaited T>
-
-    p1 = p0;
->p1 = p0 : Promise<T>
->p1 : Promise<Promise<T>>
->p0 : Promise<T>
-
-    p1 = p2;
->p1 = p2 : Promise<awaited T>
->p1 : Promise<Promise<T>>
->p2 : Promise<awaited T>
-
-    p2 = p0;
->p2 = p0 : Promise<T>
->p2 : Promise<awaited T>
->p0 : Promise<T>
-
-    p2 = p1;
->p2 = p1 : Promise<Promise<T>>
->p2 : Promise<awaited T>
->p1 : Promise<Promise<T>>
-}
-
-declare let pl0: PromiseLike<number>;
->pl0 : PromiseLike<number>
-
-declare let pl1: PromiseLike<PromiseLike<number>>;
->pl1 : PromiseLike<PromiseLike<number>>
-
-declare let pl2: PromiseLike<awaited number>;
->pl2 : PromiseLike<number>
-
-pl0 = pl1;
->pl0 = pl1 : PromiseLike<PromiseLike<number>>
->pl0 : PromiseLike<number>
->pl1 : PromiseLike<PromiseLike<number>>
-
-pl0 = pl2;
->pl0 = pl2 : PromiseLike<number>
->pl0 : PromiseLike<number>
->pl2 : PromiseLike<number>
-
-pl1 = pl0;
->pl1 = pl0 : PromiseLike<number>
->pl1 : PromiseLike<PromiseLike<number>>
->pl0 : PromiseLike<number>
-
-pl1 = pl2;
->pl1 = pl2 : PromiseLike<number>
->pl1 : PromiseLike<PromiseLike<number>>
->pl2 : PromiseLike<number>
-
-pl2 = pl0;
->pl2 = pl0 : PromiseLike<number>
->pl2 : PromiseLike<number>
->pl0 : PromiseLike<number>
-
-pl2 = pl1;
->pl2 = pl1 : PromiseLike<PromiseLike<number>>
->pl2 : PromiseLike<number>
->pl1 : PromiseLike<PromiseLike<number>>
-
-function fn2<T>(pl0: PromiseLike<T>, pl1: PromiseLike<PromiseLike<T>>, pl2: PromiseLike<awaited T>) {
->fn2 : <T>(pl0: PromiseLike<T>, pl1: PromiseLike<PromiseLike<T>>, pl2: PromiseLike<awaited T>) => void
->pl0 : PromiseLike<T>
->pl1 : PromiseLike<PromiseLike<T>>
->pl2 : PromiseLike<awaited T>
-
-    pl0 = pl1;
->pl0 = pl1 : PromiseLike<PromiseLike<T>>
->pl0 : PromiseLike<T>
->pl1 : PromiseLike<PromiseLike<T>>
-
-    pl0 = pl2;
->pl0 = pl2 : PromiseLike<awaited T>
->pl0 : PromiseLike<T>
->pl2 : PromiseLike<awaited T>
-
-    pl1 = pl0;
->pl1 = pl0 : PromiseLike<T>
->pl1 : PromiseLike<PromiseLike<T>>
->pl0 : PromiseLike<T>
-
-    pl1 = pl2;
->pl1 = pl2 : PromiseLike<awaited T>
->pl1 : PromiseLike<PromiseLike<T>>
->pl2 : PromiseLike<awaited T>
-
-    pl2 = pl0;
->pl2 = pl0 : PromiseLike<T>
->pl2 : PromiseLike<awaited T>
->pl0 : PromiseLike<T>
-
-    pl2 = pl1;
->pl2 = pl1 : PromiseLike<PromiseLike<T>>
->pl2 : PromiseLike<awaited T>
->pl1 : PromiseLike<PromiseLike<T>>
-}
-
-pl0 = p0;
->pl0 = p0 : Promise<number>
->pl0 : PromiseLike<number>
->p0 : Promise<number>
-
-pl0 = p1;
->pl0 = p1 : Promise<Promise<number>>
->pl0 : PromiseLike<number>
->p1 : Promise<Promise<number>>
-
-pl0 = p2;
->pl0 = p2 : Promise<number>
->pl0 : PromiseLike<number>
->p2 : Promise<number>
-
-pl1 = p0;
->pl1 = p0 : Promise<number>
->pl1 : PromiseLike<PromiseLike<number>>
->p0 : Promise<number>
-
-pl1 = p1;
->pl1 = p1 : Promise<Promise<number>>
->pl1 : PromiseLike<PromiseLike<number>>
->p1 : Promise<Promise<number>>
-
-pl1 = p2;
->pl1 = p2 : Promise<number>
->pl1 : PromiseLike<PromiseLike<number>>
->p2 : Promise<number>
-
-pl2 = p0;
->pl2 = p0 : Promise<number>
->pl2 : PromiseLike<number>
->p0 : Promise<number>
-
-pl2 = p1;
->pl2 = p1 : Promise<Promise<number>>
->pl2 : PromiseLike<number>
->p1 : Promise<Promise<number>>
-
-pl2 = p2;
->pl2 = p2 : Promise<number>
->pl2 : PromiseLike<number>
->p2 : Promise<number>
-
-interface A<T> {
-    x: awaited T;
->x : awaited T
-}
-
-declare let a1: A<number>;
->a1 : A<number>
-
-declare let a2: A<Promise<number>>;
->a2 : A<Promise<number>>
-
-a1 = a2;
->a1 = a2 : A<Promise<number>>
->a1 : A<number>
->a2 : A<Promise<number>>
-
-a2 = a1;
->a2 = a1 : A<number>
->a2 : A<Promise<number>>
->a1 : A<number>
-
-interface B<T> {
-    a: A<T>;
->a : A<T>
-}
-
-declare let b1: B<number>;
->b1 : B<number>
-
-declare let b2: B<Promise<number>>;
->b2 : B<Promise<number>>
-
-b1 = b2;
->b1 = b2 : B<Promise<number>>
->b1 : B<number>
->b2 : B<Promise<number>>
-
-b2 = b1;
->b2 = b1 : B<number>
->b2 : B<Promise<number>>
->b1 : B<number>
-
-interface C<T> {
-    x: awaited ({_tag: string} & T);
->x : awaited ({ _tag: string; } & T)
->_tag : string
-}
-
-declare let c1: C<number>;
->c1 : C<number>
-
-declare let c2: C<Promise<number>>;
->c2 : C<Promise<number>>
-
-// Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-c1 = c2;
->c1 = c2 : C<Promise<number>>
->c1 : C<number>
->c2 : C<Promise<number>>
-
-c2 = c1;
->c2 = c1 : C<number>
->c2 : C<Promise<number>>
->c1 : C<number>
-
-interface D<T> {
-    a: C<T>;
->a : C<T>
-}
-
-declare let d1: D<number>;
->d1 : D<number>
-
-declare let d2: D<Promise<number>>;
->d2 : D<Promise<number>>
-
-// Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-d1 = d2;
->d1 = d2 : D<Promise<number>>
->d1 : D<number>
->d2 : D<Promise<number>>
-
-d2 = d1;
->d2 = d1 : D<number>
->d2 : D<Promise<number>>
->d1 : D<number>
-
-interface E<T> {
-    x: awaited (T | {otherOption: string});
->x : { otherOption: string; } | awaited T
->otherOption : string
-}
-
-declare let e1: E<number>;
->e1 : E<number>
-
-declare let e2: E<Promise<number>>;
->e2 : E<Promise<number>>
-
-e1 = e2;
->e1 = e2 : E<Promise<number>>
->e1 : E<number>
->e2 : E<Promise<number>>
-
-e2 = e1;
->e2 = e1 : E<number>
->e2 : E<Promise<number>>
->e1 : E<number>
-
-interface F<T> {
-    a: E<T>;
->a : E<T>
-}
-
-declare let f1: F<number>;
->f1 : F<number>
-
-declare let f2: F<Promise<number>>;
->f2 : F<Promise<number>>
-
-f1 = f2;
->f1 = f2 : F<Promise<number>>
->f1 : F<number>
->f2 : F<Promise<number>>
-
-f2 = f1;
->f2 = f1 : F<number>
->f2 : F<Promise<number>>
->f1 : F<number>
-
-interface G<T, K extends keyof T> {
-    x: awaited T[K];
->x : awaited T[K]
-}
-
-declare let g1: G<{x: number}, "x">;
->g1 : G<{ x: number; }, "x">
->x : number
-
-declare let g2: G<{x: Promise<number>}, "x">;
->g2 : G<{ x: Promise<number>; }, "x">
->x : Promise<number>
-
-g1 = g2;
->g1 = g2 : G<{ x: Promise<number>; }, "x">
->g1 : G<{ x: number; }, "x">
->g2 : G<{ x: Promise<number>; }, "x">
-
-g2 = g1;
->g2 = g1 : G<{ x: number; }, "x">
->g2 : G<{ x: Promise<number>; }, "x">
->g1 : G<{ x: number; }, "x">
-
-interface H<T, K extends keyof T> {
-    a: G<T, K>;
->a : G<T, K>
-}
-
-declare let h1: H<{x: number}, "x">;
->h1 : H<{ x: number; }, "x">
->x : number
-
-declare let h2: H<{x: Promise<number>}, "x">;
->h2 : H<{ x: Promise<number>; }, "x">
->x : Promise<number>
-
-h1 = h2;
->h1 = h2 : H<{ x: Promise<number>; }, "x">
->h1 : H<{ x: number; }, "x">
->h2 : H<{ x: Promise<number>; }, "x">
-
-h2 = h1;
->h2 = h1 : H<{ x: number; }, "x">
->h2 : H<{ x: Promise<number>; }, "x">
->h1 : H<{ x: number; }, "x">
-
diff --git a/tests/baselines/reference/correctOrderOfPromiseMethod.symbols b/tests/baselines/reference/correctOrderOfPromiseMethod.symbols
index efd5ccc07b576..29a494f4ec5c3 100644
--- a/tests/baselines/reference/correctOrderOfPromiseMethod.symbols
+++ b/tests/baselines/reference/correctOrderOfPromiseMethod.symbols
@@ -33,9 +33,9 @@ async function countEverything(): Promise<number> {
     const [resultA, resultB] = await Promise.all([
 >resultA : Symbol(resultA, Decl(correctOrderOfPromiseMethod.ts, 13, 11))
 >resultB : Symbol(resultB, Decl(correctOrderOfPromiseMethod.ts, 13, 19))
->Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 7 more)
+>Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 6 more)
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 7 more)
+>all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 6 more)
 
         providerA(),
 >providerA : Symbol(providerA, Decl(correctOrderOfPromiseMethod.ts, 10, 9))
@@ -75,8 +75,8 @@ async function countEverything(): Promise<number> {
 const expected: Promise<["a", "b", "c"]> = Promise.all(undefined as readonly ["a", "b", "c"]);
 >expected : Symbol(expected, Decl(correctOrderOfPromiseMethod.ts, 28, 5))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 7 more)
+>Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 6 more)
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 7 more)
+>all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 6 more)
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/correctOrderOfPromiseMethod.types b/tests/baselines/reference/correctOrderOfPromiseMethod.types
index 6699798da9dd9..fe38cd1dfbbf5 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(),    ]) : [A[], B[]]
 >Promise.all([        providerA(),        providerB(),    ]) : Promise<[A[], B[]]>
->Promise.all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<(awaited T)[]>; <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<[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 | 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<[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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[awaited T1, awaited T2]>; <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: awaited T[P]; }>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<(awaited T)[]>; }
+>Promise.all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>; <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 : PromiseConstructor
->all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<(awaited T)[]>; <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<[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 | 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<[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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[awaited T1, awaited T2]>; <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: awaited T[P]; }>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<(awaited T)[]>; }
+>all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>; <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[]>; }
 >[        providerA(),        providerB(),    ] : [Promise<A[]>, Promise<B[]>]
 
         providerA(),
@@ -76,9 +76,9 @@ async function countEverything(): Promise<number> {
 const expected: Promise<["a", "b", "c"]> = Promise.all(undefined as readonly ["a", "b", "c"]);
 >expected : Promise<["a", "b", "c"]>
 >Promise.all(undefined as readonly ["a", "b", "c"]) : Promise<["a", "b", "c"]>
->Promise.all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<(awaited T)[]>; <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<[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 | 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<[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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[awaited T1, awaited T2]>; <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: awaited T[P]; }>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<(awaited T)[]>; }
+>Promise.all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>; <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 : PromiseConstructor
->all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<(awaited T)[]>; <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<[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 | 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<[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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[awaited T1, awaited T2]>; <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: awaited T[P]; }>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<(awaited T)[]>; }
+>all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>; <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[]>; }
 >undefined as readonly ["a", "b", "c"] : readonly ["a", "b", "c"]
 >undefined : undefined
 
diff --git a/tests/baselines/reference/covariantCallbacks.errors.txt b/tests/baselines/reference/covariantCallbacks.errors.txt
index 61faf8d40fb82..401bf454baa19 100644
--- a/tests/baselines/reference/covariantCallbacks.errors.txt
+++ b/tests/baselines/reference/covariantCallbacks.errors.txt
@@ -1,11 +1,7 @@
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/covariantCallbacks.ts(12,5): error TS2322: Type 'P<A>' is not assignable to type 'P<B>'.
   Property 'b' is missing in type 'A' but required in type 'B'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/covariantCallbacks.ts(17,5): error TS2322: Type 'Promise<A>' is not assignable to type 'Promise<B>'.
-  Types of property 'then' are incompatible.
-    Type '<TResult1 = A, TResult2 = never>(onfulfilled?: ((value: A) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>' is not assignable to type '<TResult1 = B, TResult2 = never>(onfulfilled?: ((value: B) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>'.
-      Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-        Types of parameters 'value' and 'value' are incompatible.
-          Type 'A' is not assignable to type 'B'.
+  Type 'A' is not assignable to type 'B'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/covariantCallbacks.ts(30,5): error TS2322: Type 'AList1' is not assignable to type 'BList1'.
   Types of property 'forEach' are incompatible.
     Type '(cb: (item: A) => void) => void' is not assignable to type '(cb: (item: B) => void) => void'.
@@ -52,11 +48,7 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/covarian
         b = a;  // Error
         ~
 !!! error TS2322: Type 'Promise<A>' is not assignable to type 'Promise<B>'.
-!!! error TS2322:   Types of property 'then' are incompatible.
-!!! error TS2322:     Type '<TResult1 = A, TResult2 = never>(onfulfilled?: ((value: A) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>' is not assignable to type '<TResult1 = B, TResult2 = never>(onfulfilled?: ((value: B) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>'.
-!!! error TS2322:       Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-!!! error TS2322:         Types of parameters 'value' and 'value' are incompatible.
-!!! error TS2322:           Type 'A' is not assignable to type 'B'.
+!!! error TS2322:   Type 'A' is not assignable to type 'B'.
     }
     
     interface AList1 {
diff --git a/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types b/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types
index e069c3087b9bd..bf9666f3082b1 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<awaited TResult1 | awaited TResult2>
+>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') : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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/es2018ObjectAssign.types b/tests/baselines/reference/es2018ObjectAssign.types
index ddb14ae77b965..f4cc265f67a97 100644
--- a/tests/baselines/reference/es2018ObjectAssign.types
+++ b/tests/baselines/reference/es2018ObjectAssign.types
@@ -15,7 +15,7 @@ declare const p: Promise<number>;
 
 p.finally();
 >p.finally() : Promise<number>
->p.finally : (onfinally?: () => void | PromiseLike<void>) => Promise<number>
+>p.finally : (onfinally?: () => void) => Promise<number>
 >p : Promise<number>
->finally : (onfinally?: () => void | PromiseLike<void>) => Promise<number>
+>finally : (onfinally?: () => void) => Promise<number>
 
diff --git a/tests/baselines/reference/esModuleInteropImportCall.types b/tests/baselines/reference/esModuleInteropImportCall.types
index f26b63db88bfa..59d1de3076822 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<awaited TResult1 | awaited TResult2>
+>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") : 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<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = { default: () => void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 08745abf42acf..0e6ad89ccdfe6 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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 182196ebbcb6d..180197b26eafc 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 | awaited T
+>x : T
 >source : Iterable<T> | AsyncIterable<T>
     }
 }
diff --git a/tests/baselines/reference/genericFunctionInference1.types b/tests/baselines/reference/genericFunctionInference1.types
index 06f94b743b079..2b44e9560dfcc 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<number>
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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 37f67a3933b97..fd3564b2c147c 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 d1eb4e4124a84..80580e35d5362 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<awaited TResult1 | awaited TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 58c6281aae1f1..e7f75126c1494 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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/importCallExpressionCheckReturntype1.errors.txt b/tests/baselines/reference/importCallExpressionCheckReturntype1.errors.txt
index 951d8731e4bb5..dd3445deb562f 100644
--- a/tests/baselines/reference/importCallExpressionCheckReturntype1.errors.txt
+++ b/tests/baselines/reference/importCallExpressionCheckReturntype1.errors.txt
@@ -1,15 +1,7 @@
 tests/cases/conformance/dynamicImport/1.ts(4,5): error TS2322: Type 'Promise<typeof import("tests/cases/conformance/dynamicImport/defaultPath")>' is not assignable to type 'Promise<typeof import("tests/cases/conformance/dynamicImport/anotherModule")>'.
-  Types of property 'then' are incompatible.
-    Type '<TResult1 = typeof import("tests/cases/conformance/dynamicImport/defaultPath"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/defaultPath")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>' is not assignable to type '<TResult1 = typeof import("tests/cases/conformance/dynamicImport/anotherModule"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/anotherModule")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>'.
-      Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-        Types of parameters 'value' and 'value' are incompatible.
-          Type 'typeof import("tests/cases/conformance/dynamicImport/defaultPath")' is not assignable to type 'typeof import("tests/cases/conformance/dynamicImport/anotherModule")'.
+  Property 'D' is missing in type 'typeof import("tests/cases/conformance/dynamicImport/defaultPath")' but required in type 'typeof import("tests/cases/conformance/dynamicImport/anotherModule")'.
 tests/cases/conformance/dynamicImport/1.ts(5,10): error TS2352: Conversion of type 'Promise<typeof import("tests/cases/conformance/dynamicImport/defaultPath")>' to type 'Promise<typeof import("tests/cases/conformance/dynamicImport/anotherModule")>' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.
-  Types of property 'then' are incompatible.
-    Type '<TResult1 = typeof import("tests/cases/conformance/dynamicImport/defaultPath"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/defaultPath")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>' is not comparable to type '<TResult1 = typeof import("tests/cases/conformance/dynamicImport/anotherModule"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/anotherModule")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>'.
-      Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-        Types of parameters 'value' and 'value' are incompatible.
-          Type 'typeof import("tests/cases/conformance/dynamicImport/defaultPath")' is not comparable to type 'typeof import("tests/cases/conformance/dynamicImport/anotherModule")'.
+  Property 'D' is missing in type 'typeof import("tests/cases/conformance/dynamicImport/defaultPath")' but required in type 'typeof import("tests/cases/conformance/dynamicImport/anotherModule")'.
 
 
 ==== tests/cases/conformance/dynamicImport/anotherModule.ts (0 errors) ====
@@ -25,18 +17,12 @@ tests/cases/conformance/dynamicImport/1.ts(5,10): error TS2352: Conversion of ty
     let p1: Promise<typeof anotherModule> = import("./defaultPath");
         ~~
 !!! error TS2322: Type 'Promise<typeof import("tests/cases/conformance/dynamicImport/defaultPath")>' is not assignable to type 'Promise<typeof import("tests/cases/conformance/dynamicImport/anotherModule")>'.
-!!! error TS2322:   Types of property 'then' are incompatible.
-!!! error TS2322:     Type '<TResult1 = typeof import("tests/cases/conformance/dynamicImport/defaultPath"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/defaultPath")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>' is not assignable to type '<TResult1 = typeof import("tests/cases/conformance/dynamicImport/anotherModule"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/anotherModule")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>'.
-!!! error TS2322:       Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-!!! error TS2322:         Types of parameters 'value' and 'value' are incompatible.
-!!! error TS2322:           Type 'typeof import("tests/cases/conformance/dynamicImport/defaultPath")' is not assignable to type 'typeof import("tests/cases/conformance/dynamicImport/anotherModule")'.
+!!! error TS2322:   Property 'D' is missing in type 'typeof import("tests/cases/conformance/dynamicImport/defaultPath")' but required in type 'typeof import("tests/cases/conformance/dynamicImport/anotherModule")'.
+!!! related TS2728 tests/cases/conformance/dynamicImport/anotherModule.ts:1:14: 'D' is declared here.
     let p2 = import("./defaultPath") as Promise<typeof anotherModule>;
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2352: Conversion of type 'Promise<typeof import("tests/cases/conformance/dynamicImport/defaultPath")>' to type 'Promise<typeof import("tests/cases/conformance/dynamicImport/anotherModule")>' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.
-!!! error TS2352:   Types of property 'then' are incompatible.
-!!! error TS2352:     Type '<TResult1 = typeof import("tests/cases/conformance/dynamicImport/defaultPath"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/defaultPath")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>' is not comparable to type '<TResult1 = typeof import("tests/cases/conformance/dynamicImport/anotherModule"), TResult2 = never>(onfulfilled?: (value: typeof import("tests/cases/conformance/dynamicImport/anotherModule")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>'.
-!!! error TS2352:       Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-!!! error TS2352:         Types of parameters 'value' and 'value' are incompatible.
-!!! error TS2352:           Type 'typeof import("tests/cases/conformance/dynamicImport/defaultPath")' is not comparable to type 'typeof import("tests/cases/conformance/dynamicImport/anotherModule")'.
+!!! error TS2352:   Property 'D' is missing in type 'typeof import("tests/cases/conformance/dynamicImport/defaultPath")' but required in type 'typeof import("tests/cases/conformance/dynamicImport/anotherModule")'.
+!!! related TS2728 tests/cases/conformance/dynamicImport/anotherModule.ts:1:14: 'D' is declared here.
     let p3: Promise<any> = import("./defaultPath");
     
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpressionES5AMD.types b/tests/baselines/reference/importCallExpressionES5AMD.types
index 564692b05de52..ceb6a6fe29962 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 564692b05de52..ceb6a6fe29962 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 564692b05de52..ceb6a6fe29962 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 564692b05de52..ceb6a6fe29962 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 564692b05de52..ceb6a6fe29962 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 564692b05de52..ceb6a6fe29962 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 564692b05de52..ceb6a6fe29962 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 564692b05de52..ceb6a6fe29962 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 2e2c2d2e85065..f0a055e7a0626 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 6d272d332a7d2..6d270e686edf2 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 53f3da4d2dfce..875118acbac1a 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<awaited TResult1 | awaited TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 34e6761eb6117..afedd6f4b815f 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 6d272d332a7d2..6d270e686edf2 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 53f3da4d2dfce..875118acbac1a 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<awaited TResult1 | awaited TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 584fcc2ff5826..aea65c1407070 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 6d272d332a7d2..6d270e686edf2 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 53f3da4d2dfce..875118acbac1a 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<awaited TResult1 | awaited TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 34e6761eb6117..afedd6f4b815f 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 6d272d332a7d2..6d270e686edf2 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 53f3da4d2dfce..875118acbac1a 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<awaited TResult1 | awaited TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 34e6761eb6117..afedd6f4b815f 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 8b22ef71cc4cd..ef8cdaec2fa72 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<awaited TResult1 | awaited TResult2>
+>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 : 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<awaited TResult1 | awaited TResult2>
+>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>
 >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 01f883750ae35..b5f526adc8e89 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<awaited TResult1 | awaited TResult2>
+>p1.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p1 : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 2590fd62df0a7..6c45228344687 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<awaited TResult1 | awaited TResult2>
+>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`) : 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<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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") : 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<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 dcaf760969722..6378e7c582be8 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<awaited TResult1 | awaited TResult2>
+>p1.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p1 : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >zero => {    return zero.foo();  // ok, zero is any} : (zero: any) => any
 >zero : any
 
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols
index 8deaf8a246922..ecf867a2bf715 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.symbols
@@ -381,9 +381,9 @@ const f1: F = () => {
 >F : Symbol(F, Decl(inferFromGenericFunctionReturnTypes3.ts, 153, 2))
 
     return Promise.all([
->Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 7 more)
+>Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 6 more)
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 7 more)
+>all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 6 more)
         {
             name: "David Gomes",
 >name : Symbol(name, Decl(inferFromGenericFunctionReturnTypes3.ts, 159, 9))
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
index cf5622307a04d..3d0da11bab1e2 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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 : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<(awaited T)[]>; <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<[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 | 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<[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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[awaited T1, awaited T2]>; <T extends [] | readonly unknown[]>(values: T): Promise<{ -readonly [P in keyof T]: awaited T[P]; }>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<(awaited T)[]>; }
+>Promise.all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>; <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 : PromiseConstructor
->all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<(awaited T)[]>; <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<[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 | 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<[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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[awaited T1, awaited T2]>; <T extends [] | readonly unknown[]>(values: T): Promise<{ -readonly [P in keyof T]: awaited T[P]; }>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<(awaited T)[]>; }
+>all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>; <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[]>; }
 >[        {            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.symbols b/tests/baselines/reference/inferenceLimit.symbols
index 55cf1c34802e7..4b7091a05857e 100644
--- a/tests/baselines/reference/inferenceLimit.symbols
+++ b/tests/baselines/reference/inferenceLimit.symbols
@@ -61,9 +61,9 @@ export class BrokenClass {
 
     return Promise.all(result.map(populateItems))
 >Promise.all(result.map(populateItems))      .then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 7 more)
+>Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 6 more)
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
->all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 7 more)
+>all : Symbol(PromiseConstructor.all, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --) ... and 6 more)
 >result.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(file1.ts, 10, 7))
 >map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types
index 1eb43601bbdd3..573087cca8e25 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<awaited TResult1 | awaited TResult2>
+>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) : 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<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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)) : Promise<unknown[]>
->Promise.all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<(awaited T)[]>; <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<[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 | 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<[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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[awaited T1, awaited T2]>; <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: awaited T[P]; }>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<(awaited T)[]>; }
+>Promise.all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>; <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 : PromiseConstructor
->all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<(awaited T)[]>; <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<[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 | 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<[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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<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 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[awaited T1, awaited T2]>; <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: awaited T[P]; }>; <T>(values: readonly (T | PromiseLike<T>)[]): Promise<(awaited T)[]>; }
+>all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>; <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[]>; }
 >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<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = unknown[], TResult2 = never>(onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 acb790935ff6f..b5317b6f7561f 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<awaited TResult1 | awaited TResult2>
+>Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >Promise.resolve() : Promise<void>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited 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<awaited TResult1 | awaited TResult2>
+>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>
 >() => {			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<awaited TResult1 | awaited TResult2>
+>Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >Promise.resolve() : Promise<void>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited 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<awaited TResult1 | awaited TResult2>
+>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>
 >() => {			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<awaited TResult1 | awaited TResult2>
+>Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >Promise.resolve() : Promise<void>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited 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<awaited TResult1 | awaited TResult2>
+>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>
 >() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'SOMETHING';		} : () => "SOMETHING"
 
 			if (1 < 2) {
diff --git a/tests/baselines/reference/jsFileCompilationAwaitModifier.types b/tests/baselines/reference/jsFileCompilationAwaitModifier.types
index 8b71bdc6ddeaf..b4fe2405adadf 100644
--- a/tests/baselines/reference/jsFileCompilationAwaitModifier.types
+++ b/tests/baselines/reference/jsFileCompilationAwaitModifier.types
@@ -8,9 +8,9 @@ class Foo {
         await Promise.resolve(1);
 >await Promise.resolve(1) : number
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >1 : 1
     }
 
@@ -21,9 +21,9 @@ class Foo {
         await Promise.resolve(1);
 >await Promise.resolve(1) : number
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >1 : 1
     }
 }
diff --git a/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.types b/tests/baselines/reference/jsdocArrayObjectPromiseImplicitAny.types
index 8bfec84987bf1..3fab5033c2305 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >5 : 5
 
 /**
diff --git a/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.types b/tests/baselines/reference/jsdocArrayObjectPromiseNoImplicitAny.types
index e846ada0294ad..82ff886f1ec68 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >5 : 5
 
 /**
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
index f25dd08ae1ab6..c9a0476c2adcf 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<awaited TResult1 | awaited TResult2>
+>out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 105969d7a24fe..a695213a42ccd 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<awaited TResult1 | awaited TResult2>
+>out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 87ef0159c4558..3e7c23fde87ac 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<awaited TResult1 | awaited TResult2>
+>out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => {    console.log("Yea!");} : () => void
 
     console.log("Yea!");
diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.types b/tests/baselines/reference/noImplicitReturnsInAsync1.types
index 1198e8208e134..dd468d33e6e21 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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 e4e9dc5760480..a1975cc3645e0 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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <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>; }
 >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 742f56f117f6a..8b70977a0e5a2 100644
--- a/tests/baselines/reference/promisePermutations.errors.txt
+++ b/tests/baselines/reference/promisePermutations.errors.txt
@@ -117,18 +117,14 @@ tests/cases/compiler/promisePermutations.ts(158,21): error TS2769: No overload m
 tests/cases/compiler/promisePermutations.ts(159,21): error TS2769: No overload matches this call.
   The last overload gave the following error.
     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => Promise<string>'.
-      Call signature return types 'Promise<number>' and 'Promise<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<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 '{ <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }'.
-            Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-              Types of parameters 'value' and 'value' are incompatible.
-                Type 'number' is not assignable to type 'string'.
+      Type 'Promise<number>' is not assignable to type 'Promise<string>'.
+        Type 'number' is not assignable to type 'string'.
 tests/cases/compiler/promisePermutations.ts(160,21): error TS2769: No overload matches this call.
   The last overload gave the following error.
     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<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>; }'.
+          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>; }'.
             Types of parameters 'onfulfilled' and 'success' are incompatible.
               Types of parameters 'value' and 'value' are incompatible.
                 Type 'number' is not assignable to type 'string'.
@@ -477,12 +473,8 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2769: No overload m
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   The last overload gave the following error.
 !!! error TS2769:     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => Promise<string>'.
-!!! error TS2769:       Call signature return types 'Promise<number>' and 'Promise<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<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 '{ <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }'.
-!!! error TS2769:             Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-!!! error TS2769:               Types of parameters 'value' and 'value' are incompatible.
-!!! error TS2769:                 Type 'number' is not assignable to type 'string'.
+!!! error TS2769:       Type 'Promise<number>' is not assignable to type 'Promise<string>'.
+!!! error TS2769:         Type 'number' is not assignable to type 'string'.
 !!! related TS2771 tests/cases/compiler/promisePermutations.ts:5:5: The last overload is declared here.
     var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
                         ~~~~~~~~~~~~~~~
@@ -491,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<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:           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:             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 d7b0e33e47d1b..9a4607fb75d61 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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >testFunctionP : () => Promise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : 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<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.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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
->then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<number>
 >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise<number>
->s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s4.then(testFunction4, testFunction4, testFunction4) : Promise<string>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise<string>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s4.then(testFunction4P, testFunction4, testFunction4) : Promise<string>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<string>>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s5.then(testFunction5, testFunction5, testFunction5) : Promise<string>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise<string>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s5.then(testFunction5P, testFunction5, testFunction5) : Promise<string>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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).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) : Promise<string>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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>; }
+>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>; }
 >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 : Promise<string>
 >s6.then(testFunction6, testFunction6, testFunction6) : Promise<string>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise<string>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s6.then(testFunction6P, testFunction6, testFunction6) : Promise<string>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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).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) : Promise<string>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s8.then(testFunction8, testFunction8, testFunction8) : Promise<unknown>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise<unknown>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s8.then(testFunction8P, testFunction8, testFunction8) : Promise<unknown>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s9.then(testFunction9, testFunction9, testFunction9) : Promise<unknown>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise<unknown>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s9.then(testFunction9P, testFunction9, testFunction9) : Promise<unknown>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<number>
 >s9.then(testFunction, sIPromise, nIPromise) : Promise<number>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >testFunction : () => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<number>
 >s10.then(testFunctionP, sIPromise, nIPromise) : Promise<number>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >testFunctionP : () => Promise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s11.then(testFunction11, testFunction11, testFunction11) : Promise<string>
->s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise<string>
->s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s11.then(testFunction11P, testFunction11, testFunction11) : Promise<string>
->s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 4cc2f1cc0cfc2..bc676c9dd5e85 100644
--- a/tests/baselines/reference/promisePermutations2.errors.txt
+++ b/tests/baselines/reference/promisePermutations2.errors.txt
@@ -77,16 +77,12 @@ tests/cases/compiler/promisePermutations2.ts(155,21): error TS2769: No overload
 tests/cases/compiler/promisePermutations2.ts(157,21): error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
   Type 'IPromise<number>' is not assignable to type 'IPromise<string>'.
 tests/cases/compiler/promisePermutations2.ts(158,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => Promise<string>'.
-  Call signature return types 'Promise<number>' and 'Promise<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<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
-        Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-          Types of parameters 'value' and 'value' are incompatible.
-            Type 'number' is not assignable to type 'string'.
+  Type 'Promise<number>' is not assignable to type 'Promise<string>'.
+    Type 'number' is not assignable to type 'string'.
 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<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>; }'.
+      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>; }'.
         Types of parameters 'onfulfilled' and 'success' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'number' is not assignable to type 'string'.
@@ -375,18 +371,14 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
     var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
                         ~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => Promise<string>'.
-!!! error TS2345:   Call signature return types 'Promise<number>' and 'Promise<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<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
-!!! error TS2345:         Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-!!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
-!!! error TS2345:             Type 'number' is not assignable to type 'string'.
+!!! error TS2345:   Type 'Promise<number>' is not assignable to type 'Promise<string>'.
+!!! error TS2345:     Type 'number' is not assignable to type 'string'.
     var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
                         ~~~~~~~~~~~~~~~
 !!! 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<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:       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:         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 e72a2c3eace68..49a704375bac0 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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >testFunctionP : () => Promise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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: 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : 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<awaited TResult1 | awaited 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 | 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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
->then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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: 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<IPromise<number>>
 >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise<IPromise<number>>
->s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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: 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>; }
 >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 : Promise<IPromise<string>>
 >s4.then(testFunction4, testFunction4, testFunction4) : Promise<IPromise<string>>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<Promise<string>>
 >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise<Promise<string>>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<IPromise<string>>
 >s4.then(testFunction4P, testFunction4, testFunction4) : Promise<IPromise<string>>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<string>>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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: 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>; }
 >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 : Promise<IPromise<string>>
 >s5.then(testFunction5, testFunction5, testFunction5) : Promise<IPromise<string>>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<Promise<string>>
 >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise<Promise<string>>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<IPromise<string>>
 >s5.then(testFunction5P, testFunction5, testFunction5) : Promise<IPromise<string>>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<Promise<string>>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
->then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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: 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>; }
 >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 : Promise<IPromise<string>>
 >s6.then(testFunction6, testFunction6, testFunction6) : Promise<IPromise<string>>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<Promise<string>>
 >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise<Promise<string>>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<IPromise<string>>
 >s6.then(testFunction6P, testFunction6, testFunction6) : Promise<IPromise<string>>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<Promise<string>>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
 >sPromise : (x: any) => Promise<string>
->then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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: 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>; }
 >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 : Promise<unknown>
 >s8.then(testFunction8, testFunction8, testFunction8) : Promise<unknown>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<unknown>
 >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise<unknown>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<unknown>
 >s8.then(testFunction8P, testFunction8, testFunction8) : Promise<unknown>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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: 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>; }
 >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 : Promise<unknown>
 >s9.then(testFunction9, testFunction9, testFunction9) : Promise<unknown>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<unknown>
 >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise<unknown>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<unknown>
 >s9.then(testFunction9P, testFunction9, testFunction9) : Promise<unknown>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<IPromise<number>>
 >s9.then(testFunction, sIPromise, nIPromise) : Promise<IPromise<number>>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >testFunction : () => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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: 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<Promise<number>>
 >s10.then(testFunctionP, sIPromise, nIPromise) : Promise<Promise<number>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >testFunctionP : () => Promise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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: 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>; }
 >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 : Promise<IPromise<string>>
 >s11.then(testFunction11, testFunction11, testFunction11) : Promise<IPromise<string>>
->s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<Promise<string>>
 >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise<Promise<string>>
->s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 : Promise<IPromise<string>>
 >s11.then(testFunction11P, testFunction11, testFunction11) : Promise<IPromise<string>>
->s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 4f47b6bef697c..7467009abce93 100644
--- a/tests/baselines/reference/promisePermutations3.errors.txt
+++ b/tests/baselines/reference/promisePermutations3.errors.txt
@@ -96,18 +96,14 @@ tests/cases/compiler/promisePermutations3.ts(157,21): error TS2769: No overload
 tests/cases/compiler/promisePermutations3.ts(158,21): error TS2769: No overload matches this call.
   The last overload gave the following error.
     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => Promise<string>'.
-      Call signature return types 'Promise<number>' and 'Promise<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<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 '{ <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }'.
-            Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-              Types of parameters 'value' and 'value' are incompatible.
-                Type 'number' is not assignable to type 'string'.
+      Type 'Promise<number>' is not assignable to type 'Promise<string>'.
+        Type 'number' is not assignable to type 'string'.
 tests/cases/compiler/promisePermutations3.ts(159,21): error TS2769: No overload matches this call.
   The last overload gave the following error.
     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<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>'.
+          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>'.
             Types of parameters 'onfulfilled' and 'success' are incompatible.
               Types of parameters 'value' and 'value' are incompatible.
                 Type 'number' is not assignable to type 'string'.
@@ -425,12 +421,8 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2769: No overload matches this call.
 !!! error TS2769:   The last overload gave the following error.
 !!! error TS2769:     Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => Promise<string>'.
-!!! error TS2769:       Call signature return types 'Promise<number>' and 'Promise<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<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 '{ <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }'.
-!!! error TS2769:             Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-!!! error TS2769:               Types of parameters 'value' and 'value' are incompatible.
-!!! error TS2769:                 Type 'number' is not assignable to type 'string'.
+!!! error TS2769:       Type 'Promise<number>' is not assignable to type 'Promise<string>'.
+!!! error TS2769:         Type 'number' is not assignable to type 'string'.
 !!! related TS2771 tests/cases/compiler/promisePermutations3.ts:7:5: The last overload is declared here.
     var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
                         ~~~~~~~~~~~~~~~
@@ -439,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<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:           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:             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 8222252b9232a..9ce0662c27a19 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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >testFunctionP : () => Promise<number>
 >testFunction : () => IPromise<number>
 >testFunction : () => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : 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<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.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 : Promise<{ x: number; }>
->then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >testFunction2P : () => Promise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
 >testFunction2 : () => IPromise<{ x: number; }>
->then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<number>
 >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise<number>
->s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >testFunction3P : (x: number) => Promise<number>
 >testFunction3 : (x: number) => IPromise<number>
 >testFunction3 : (x: number) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s4.then(testFunction4, testFunction4, testFunction4) : Promise<string>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise<string>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s4.then(testFunction4P, testFunction4, testFunction4) : Promise<string>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<string>>
->s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s5.then(testFunction5, testFunction5, testFunction5) : Promise<string>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise<string>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s5.then(testFunction5P, testFunction5, testFunction5) : Promise<string>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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).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) : Promise<string>
->s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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>; }
+>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>; }
 >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 : Promise<string>
 >s6.then(testFunction6, testFunction6, testFunction6) : Promise<string>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise<string>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s6.then(testFunction6P, testFunction6, testFunction6) : Promise<string>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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).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) : Promise<string>
->s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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 : { <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 : Promise<string>
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s8.then(testFunction8, testFunction8, testFunction8) : Promise<unknown>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise<unknown>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s8.then(testFunction8P, testFunction8, testFunction8) : Promise<unknown>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s9.then(testFunction9, testFunction9, testFunction9) : Promise<unknown>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise<unknown>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<unknown>
 >s9.then(testFunction9P, testFunction9, testFunction9) : Promise<unknown>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<number>
 >s9.then(testFunction, sIPromise, nIPromise) : Promise<number>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >testFunction : () => IPromise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<number>
 >s10.then(testFunctionP, sIPromise, nIPromise) : Promise<number>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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).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) : Promise<IPromise<number>>
->s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<unknown>
->then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >testFunctionP : () => Promise<number>
 >nIPromise : (x: any) => IPromise<number>
 >sIPromise : (x: any) => IPromise<string>
->then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s11.then(testFunction11, testFunction11, testFunction11) : Promise<string>
->s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise<string>
->s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 : Promise<string>
 >s11.then(testFunction11P, testFunction11, testFunction11) : Promise<string>
->s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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.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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<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>; }
+>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>; }
 >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 03c9683e2e7d8..3d250c11c1f87 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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <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>; }
 >success : (value: T) => Promise<A>
 >value : T
 
     then<B>(success?: (value: T) => B): Promise<B>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <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>; }
 >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<awaited TResult1 | awaited 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 | 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 : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited 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 | 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>; }
 >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 27f6c2c46b2d2..dd20fb656ea5a 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<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => null : () => any
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => null : () => any
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => {} : () => void
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => {} : () => void
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<T>
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<T>
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<T>
 >1 : 1
 
diff --git a/tests/baselines/reference/promiseTypeStrictNull.types b/tests/baselines/reference/promiseTypeStrictNull.types
index a8a070066fe2c..73d2f70346135 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<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | 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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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 | awaited TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | awaited TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => null : () => null
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => null : () => null
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => {} : () => void
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => {} : () => void
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<T>
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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 : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<T>
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : <T = never>(reason?: any) => Promise<awaited T>
+>Promise.reject : <T = never>(reason?: any) => Promise<T>
 >Promise : PromiseConstructor
->reject : <T = never>(reason?: any) => Promise<awaited T>
+>reject : <T = never>(reason?: any) => Promise<T>
 >1 : 1
 
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.types b/tests/baselines/reference/promiseVoidErrorCallback.types
index 68905c16cb431..a1388cb04ef69 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited TResult1 | awaited TResult2>
+>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;}) : Promise<T2>
->f1()    .then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>f1()    .then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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<awaited TResult1 | awaited TResult2>
+>then : <TResult1 = T2, TResult2 = never>(onfulfilled?: (value: T2) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | 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 355bd586216a6..0640f0135498f 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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: T) => U): Promise<U>; <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>; }
 >success : (value: T) => U
 >value : T
 
     then<U>(success?: (value: T) => Promise<U>): Promise<U>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: T) => U): Promise<U>; <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>; }
 >success : (value: T) => Promise<U>
 >value : T
 
diff --git a/tests/baselines/reference/promisesWithConstraints.errors.txt b/tests/baselines/reference/promisesWithConstraints.errors.txt
index 0817c2fef6ef3..e85c6764b8b14 100644
--- a/tests/baselines/reference/promisesWithConstraints.errors.txt
+++ b/tests/baselines/reference/promisesWithConstraints.errors.txt
@@ -1,9 +1,5 @@
 tests/cases/compiler/promisesWithConstraints.ts(15,1): error TS2322: Type 'Promise<Foo>' is not assignable to type 'Promise<Bar>'.
-  Types of property 'then' are incompatible.
-    Type '{ <TResult1 = Foo, TResult2 = never>(onfulfilled?: (value: Foo) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <U>(cb: (x: Foo) => Promise<U>): Promise<U>; }' is not assignable to type '{ <TResult1 = Bar, TResult2 = never>(onfulfilled?: (value: Bar) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <U>(cb: (x: Bar) => Promise<U>): Promise<U>; }'.
-      Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-        Types of parameters 'value' and 'value' are incompatible.
-          Type 'Foo' is not assignable to type 'Bar'.
+  Property 'y' is missing in type 'Foo' but required in type 'Bar'.
 tests/cases/compiler/promisesWithConstraints.ts(20,1): error TS2322: Type 'CPromise<Foo>' is not assignable to type 'CPromise<Bar>'.
   Type 'Foo' is not assignable to type 'Bar'.
 
@@ -26,11 +22,8 @@ tests/cases/compiler/promisesWithConstraints.ts(20,1): error TS2322: Type 'CProm
     b = a; // ok
     ~
 !!! error TS2322: Type 'Promise<Foo>' is not assignable to type 'Promise<Bar>'.
-!!! error TS2322:   Types of property 'then' are incompatible.
-!!! error TS2322:     Type '{ <TResult1 = Foo, TResult2 = never>(onfulfilled?: (value: Foo) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <U>(cb: (x: Foo) => Promise<U>): Promise<U>; }' is not assignable to type '{ <TResult1 = Bar, TResult2 = never>(onfulfilled?: (value: Bar) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <U>(cb: (x: Bar) => Promise<U>): Promise<U>; }'.
-!!! error TS2322:       Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-!!! error TS2322:         Types of parameters 'value' and 'value' are incompatible.
-!!! error TS2322:           Type 'Foo' is not assignable to type 'Bar'.
+!!! error TS2322:   Property 'y' is missing in type 'Foo' but required in type 'Bar'.
+!!! related TS2728 tests/cases/compiler/promisesWithConstraints.ts:10:20: 'y' is declared here.
     
     var a2: CPromise<Foo>;
     var b2: CPromise<Bar>;
diff --git a/tests/baselines/reference/promisesWithConstraints.types b/tests/baselines/reference/promisesWithConstraints.types
index 2afce5cd5b510..367cd6a61a677 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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <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>; }
 >cb : (x: T) => Promise<U>
 >x : T
 }
diff --git a/tests/baselines/reference/specializationError.types b/tests/baselines/reference/specializationError.types
index 9e55e4bd4f11e..8f0b5747bfa9d 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: awaited T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<awaited TResult1 | awaited TResult2>; <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; }
 >value : T
 }
 
diff --git a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types
index a1b482b08c035..3f1ef83a0ae9c 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<awaited TResult1 | awaited TResult2>
+>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") : 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<awaited TResult1 | awaited TResult2>
+>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>
 >({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 335151941e723..061342eaf44b0 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<awaited T>; (): Promise<void>; }
+>Bluebird.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Bluebird : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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 4750468a34618..3c6e51c56d220 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >1 : 1
 }
 async function * nextType1(): { next(...args: [] | [number | PromiseLike<number>]): any } {
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
index 3c02a66a97a1d..3d588abf1ee84 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
@@ -2,13 +2,12 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(8,12): error TS2504: Type 'Promise<number[]>' must have a '[Symbol.asyncIterator]()' method that returns an async iterator.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(10,7): error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterableIterator<number>'.
   Call signature return types 'AsyncGenerator<string, void, undefined>' and 'AsyncIterableIterator<number>' are incompatible.
-    The types of 'next(...).then' are incompatible between these types.
-      Type '<TResult1 = IteratorResult<string, void>, TResult2 = never>(onfulfilled?: (value: IteratorResult<string, void>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>' is not assignable to type '<TResult1 = IteratorResult<number, any>, TResult2 = never>(onfulfilled?: (value: IteratorResult<number, any>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>'.
-        Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-          Types of parameters 'value' and 'value' are incompatible.
-            Type 'IteratorResult<string, void>' is not assignable to type 'IteratorResult<number, any>'.
-              Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
-                Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+    The types returned by 'next(...)' are incompatible between these types.
+      Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+        Type 'IteratorResult<string, void>' is not assignable to type 'IteratorResult<number, any>'.
+          Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
+            Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+              Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(13,7): error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterableIterator<number>'.
   Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterableIterator<number>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(16,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterableIterator<number>'.
@@ -68,13 +67,12 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(
           ~~~~~~~~~~~~~~
 !!! error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterableIterator<number>'.
 !!! error TS2322:   Call signature return types 'AsyncGenerator<string, void, undefined>' and 'AsyncIterableIterator<number>' are incompatible.
-!!! error TS2322:     The types of 'next(...).then' are incompatible between these types.
-!!! error TS2322:       Type '<TResult1 = IteratorResult<string, void>, TResult2 = never>(onfulfilled?: (value: IteratorResult<string, void>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>' is not assignable to type '<TResult1 = IteratorResult<number, any>, TResult2 = never>(onfulfilled?: (value: IteratorResult<number, any>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>'.
-!!! error TS2322:         Types of parameters 'onfulfilled' and 'onfulfilled' are incompatible.
-!!! error TS2322:           Types of parameters 'value' and 'value' are incompatible.
-!!! error TS2322:             Type 'IteratorResult<string, void>' is not assignable to type 'IteratorResult<number, any>'.
-!!! error TS2322:               Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
-!!! error TS2322:                 Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+!!! error TS2322:     The types returned by 'next(...)' are incompatible between these types.
+!!! error TS2322:       Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+!!! error TS2322:         Type 'IteratorResult<string, void>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:           Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:             Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+!!! error TS2322:               Type 'string' is not assignable to type 'number'.
         yield "a";
     };
     const assignability2: () => AsyncIterableIterator<number> = async function * () {
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.types b/tests/baselines/reference/types.asyncGenerators.es2018.2.types
index d08ea642f67f4..8352487119937 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<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 5cdd44534786f..72d60545e6a51 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<awaited TResult1 | awaited TResult2>
+>Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
 >Promise.resolve() : Promise<void>
->Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
->then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<awaited TResult1 | awaited TResult2>
+>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>
 >() => ({ 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 30e30d3ed0a2e..a321593c11a8c 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >constCall : unique symbol
 
 const arrayOfConstCall = [constCall];
diff --git a/tests/baselines/reference/uniqueSymbolsDeclarations.types b/tests/baselines/reference/uniqueSymbolsDeclarations.types
index 202f93ba44109..bacdafc5680db 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<awaited T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T | PromiseLike<T>): Promise<awaited T>; (): Promise<void>; }
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >constCall : unique symbol
 
 const arrayOfConstCall = [constCall];
diff --git a/tests/baselines/reference/usePromiseFinally.types b/tests/baselines/reference/usePromiseFinally.types
index d8788f42ea03d..b704e54231cfd 100644
--- a/tests/baselines/reference/usePromiseFinally.types
+++ b/tests/baselines/reference/usePromiseFinally.types
@@ -2,7 +2,7 @@
 let promise1 = new Promise(function(resolve, reject) {})
 >promise1 : Promise<unknown>
 >new Promise(function(resolve, reject) {})                .finally(function() {}) : Promise<unknown>
->new Promise(function(resolve, reject) {})                .finally : (onfinally?: () => void | PromiseLike<void>) => Promise<unknown>
+>new Promise(function(resolve, reject) {})                .finally : (onfinally?: () => void) => Promise<unknown>
 >new Promise(function(resolve, reject) {}) : Promise<unknown>
 >Promise : PromiseConstructor
 >function(resolve, reject) {} : (resolve: (value?: unknown) => void, reject: (reason?: any) => void) => void
@@ -10,6 +10,6 @@ let promise1 = new Promise(function(resolve, reject) {})
 >reject : (reason?: any) => void
 
                 .finally(function() {});
->finally : (onfinally?: () => void | PromiseLike<void>) => Promise<unknown>
+>finally : (onfinally?: () => void) => Promise<unknown>
 >function() {} : () => void
 
diff --git a/tests/cases/conformance/types/awaited/awaited.ts b/tests/cases/conformance/types/awaited/awaited.ts
deleted file mode 100644
index 91564b4945c24..0000000000000
--- a/tests/cases/conformance/types/awaited/awaited.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-// @target: es2015
-// @declaration: true
-// simple
-declare const p0: Promise<number>;
-p0.then(x => x);
-
-declare const p1: Promise<Promise<number>>;
-p1.then(x => x);
-
-declare const p2: Promise<number | Promise<number>>;
-p2.then(x => x);
-
-// generics
-declare const f: boolean;
-declare function makePromise<T>(x: T): Promise<T>;
-makePromise(1).then(x => x);
-makePromise("a").then(x => x);
-makePromise({ a: 1 }).then(x => x);
-makePromise(f ? 1 : "a").then(x => x);
-
-function f0<U>(u: U) {
-    return makePromise(u).then(x => x);
-}
-f0(1).then(x => x);
-f0("a").then(x => x);
-f0(f ? 1 : "a").then(x => x);
-f0(makePromise(1)).then(x => x);
-
-function f1<U, V>(u: U, v: V) {
-    return makePromise(u).then(x => {
-        if (f) return x;
-        return makePromise(v).then(x => x);
-    });
-}
-f1(1, "a").then(x => x);
-f1(makePromise(1), makePromise("a")).then(x => x);
-
-function f2<U>(u: U) {
-    return makePromise(u).then(x => {
-        if (f) return x;
-        return Promise.reject("b");
-    });
-}
-f2(1).then(x => x);
-f2(makePromise(1)).then(x => x);
-
-function f3<U, V>(u: U, v: V) {
-    return makePromise(u).catch(x => v);
-}
-f3(1, "a").then(x => x);
-f3(makePromise(1), makePromise("a")).then(x => x);
-
-function f4<U, V>(u: U, v: V) {
-    return makePromise(u).catch(x => {
-        if (f) return v;
-        return Promise.reject("b");
-    });
-}
-f4(1, "a").then(x => x);
-f4(makePromise(1), makePromise("a")).then(x => x);
-
-async function f5<U>(u: Promise<U>) {
-    return await u;
-}
-f5(makePromise(1)).then(x => x);
-f5(makePromise(makePromise(1))).then(x => x);
-
-async function f6<U>(u: Promise<Promise<U>>) {
-    return await u;
-}
-
-// assignability
-let v0: number;
-let v1: awaited number;
-let v2: awaited Promise<number>;
-v0 = v1;
-v0 = v2;
-v1 = v0;
-v1 = v2;
-v2 = v0;
-v2 = v1;
-
-function f7<U>() {
-    let v0: awaited U;
-    let v1: awaited Promise<U>;
-    v0 = v1;
-    v1 = v0;
-}
-
-async function f8<U>() {
-    let pu: Promise<U>;
-    let v0: awaited U;
-    let v1: awaited Promise<U>;
-    v0 = await pu;
-    v1 = await pu;
-}
\ No newline at end of file
diff --git a/tests/cases/conformance/types/awaited/awaitedInference.ts b/tests/cases/conformance/types/awaited/awaitedInference.ts
deleted file mode 100644
index fcc88aee6d92c..0000000000000
--- a/tests/cases/conformance/types/awaited/awaitedInference.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-declare function foo<T>(f: () => PromiseLike<T>, x: T): void;
-declare const nullOrNumber: number | null;
-foo(async () => nullOrNumber, null);
-
-type UnwrapAwaited<T> = T extends awaited infer Inner ? Inner : T;
-type Result1 = UnwrapAwaited<awaited Promise<number>>; // number
-type Result2 = UnwrapAwaited<awaited Promise<number> | number>; // number
-function f<T>() {
-    type Result1 = UnwrapAwaited<T>; // UnwrapAwaited<T>
-    type Result2 = UnwrapAwaited<awaited T>; // UnwrapAwaited<awaited T>
-    return null as any as [Result1, Result2];
-}
-const x = f<number>(); // number
-const y = f<Promise<number>>(); // number ?
-const z = f<Promise<number> | number>(); // number ?
\ No newline at end of file
diff --git a/tests/cases/conformance/types/awaited/awaitedVariance.ts b/tests/cases/conformance/types/awaited/awaitedVariance.ts
deleted file mode 100644
index 6aa4584412daf..0000000000000
--- a/tests/cases/conformance/types/awaited/awaitedVariance.ts
+++ /dev/null
@@ -1,123 +0,0 @@
-// @target: es2015
-
-declare let p0: Promise<number>;
-declare let p1: Promise<Promise<number>>;
-declare let p2: Promise<awaited number>;
-p0 = p1;
-p0 = p2;
-p1 = p0;
-p1 = p2;
-p2 = p0;
-p2 = p1;
-
-function fn1<T>(p0: Promise<T>, p1: Promise<Promise<T>>, p2: Promise<awaited T>) {
-    p0 = p1;
-    p0 = p2;
-    p1 = p0;
-    p1 = p2;
-    p2 = p0;
-    p2 = p1;
-}
-
-declare let pl0: PromiseLike<number>;
-declare let pl1: PromiseLike<PromiseLike<number>>;
-declare let pl2: PromiseLike<awaited number>;
-pl0 = pl1;
-pl0 = pl2;
-pl1 = pl0;
-pl1 = pl2;
-pl2 = pl0;
-pl2 = pl1;
-
-function fn2<T>(pl0: PromiseLike<T>, pl1: PromiseLike<PromiseLike<T>>, pl2: PromiseLike<awaited T>) {
-    pl0 = pl1;
-    pl0 = pl2;
-    pl1 = pl0;
-    pl1 = pl2;
-    pl2 = pl0;
-    pl2 = pl1;
-}
-
-pl0 = p0;
-pl0 = p1;
-pl0 = p2;
-pl1 = p0;
-pl1 = p1;
-pl1 = p2;
-pl2 = p0;
-pl2 = p1;
-pl2 = p2;
-
-interface A<T> {
-    x: awaited T;
-}
-
-declare let a1: A<number>;
-declare let a2: A<Promise<number>>;
-a1 = a2;
-a2 = a1;
-
-interface B<T> {
-    a: A<T>;
-}
-
-declare let b1: B<number>;
-declare let b2: B<Promise<number>>;
-b1 = b2;
-b2 = b1;
-
-interface C<T> {
-    x: awaited ({_tag: string} & T);
-}
-
-declare let c1: C<number>;
-declare let c2: C<Promise<number>>;
-// Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-c1 = c2;
-c2 = c1;
-
-interface D<T> {
-    a: C<T>;
-}
-
-declare let d1: D<number>;
-declare let d2: D<Promise<number>>;
-// Not assignable since `awaited ({_tag: string} & Promise<number>)` is `number`, which isn't assignable to `({_tag: string} & number)`.
-d1 = d2;
-d2 = d1;
-
-interface E<T> {
-    x: awaited (T | {otherOption: string});
-}
-
-declare let e1: E<number>;
-declare let e2: E<Promise<number>>;
-e1 = e2;
-e2 = e1;
-
-interface F<T> {
-    a: E<T>;
-}
-
-declare let f1: F<number>;
-declare let f2: F<Promise<number>>;
-f1 = f2;
-f2 = f1;
-
-interface G<T, K extends keyof T> {
-    x: awaited T[K];
-}
-
-declare let g1: G<{x: number}, "x">;
-declare let g2: G<{x: Promise<number>}, "x">;
-g1 = g2;
-g2 = g1;
-
-interface H<T, K extends keyof T> {
-    a: G<T, K>;
-}
-
-declare let h1: H<{x: number}, "x">;
-declare let h2: H<{x: Promise<number>}, "x">;
-h1 = h2;
-h2 = h1;
\ No newline at end of file