diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index affd70572c9..a1dc4653c90 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -356,7 +356,7 @@ namespace ts {
         const visitedFlowTypes: FlowType[] = [];
         const potentialThisCollisions: Node[] = [];
         const potentialNewTargetCollisions: Node[] = [];
-        const promisedTypeStack: Type[] = [];
+        const awaitedTypeStack: Type[] = [];
 
         const diagnostics = createDiagnosticCollection();
 
@@ -2537,10 +2537,10 @@ namespace ts {
                     const indexTypeNode = typeToTypeNodeHelper((<IndexedAccessType>type).indexType, context);
                     return createIndexedAccessTypeNode(objectTypeNode, indexTypeNode);
                 }
-                if (type.flags & TypeFlags.Promised) {
-                    const indexedType = (<PromisedType>type).type;
+                if (type.flags & TypeFlags.Awaited) {
+                    const indexedType = (<AwaitedType>type).type;
                     const indexTypeNode = typeToTypeNodeHelper(indexedType, context);
-                    return createTypeOperatorNode(indexTypeNode, SyntaxKind.PromisedKeyword);
+                    return createTypeOperatorNode(indexTypeNode, SyntaxKind.AwaitedKeyword);
                 }
 
                 Debug.fail("Should be unreachable.");
@@ -3311,13 +3311,13 @@ namespace ts {
                         writeType((<IndexedAccessType>type).indexType, TypeFormatFlags.None);
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                     }
-                    else if (type.flags & TypeFlags.Promised) {
+                    else if (type.flags & TypeFlags.Awaited) {
                         if (flags & TypeFormatFlags.InElementType) {
                             writePunctuation(writer, SyntaxKind.OpenParenToken);
                         }
-                        writer.writeKeyword("promised");
+                        writer.writeKeyword("awaited");
                         writeSpace(writer);
-                        writeType((<PromisedType>type).type, TypeFormatFlags.InElementType);
+                        writeType((<AwaitedType>type).type, TypeFormatFlags.InElementType);
                         if (flags & TypeFormatFlags.InElementType) {
                             writePunctuation(writer, SyntaxKind.CloseParenToken);
                         }
@@ -6024,9 +6024,9 @@ namespace ts {
                     const baseIndexedAccess = baseObjectType && baseIndexType ? getIndexedAccessType(baseObjectType, baseIndexType) : undefined;
                     return baseIndexedAccess && baseIndexedAccess !== unknownType ? getBaseConstraint(baseIndexedAccess) : undefined;
                 }
-                if (t.flags & TypeFlags.Promised) {
-                    const basePromiseType = getBaseConstraint((<PromisedType>t).type);
-                    return basePromiseType ? getPromisedType(basePromiseType) : undefined;
+                if (t.flags & TypeFlags.Awaited) {
+                    const basePromiseType = getBaseConstraint((<AwaitedType>t).type);
+                    return basePromiseType ? getAwaitedType(basePromiseType) : undefined;
                 }
                 if (isGenericMappedType(t)) {
                     return emptyObjectType;
@@ -7568,8 +7568,8 @@ namespace ts {
                     case SyntaxKind.KeyOfKeyword:
                         links.resolvedType = getIndexType(type);
                         break;
-                    case SyntaxKind.PromisedKeyword:
-                        links.resolvedType = getPromisedType(type) || unknownType;
+                    case SyntaxKind.AwaitedKeyword:
+                        links.resolvedType = getAwaitedType(type) || unknownType;
                         break;
                 }
             }
@@ -8398,8 +8398,8 @@ namespace ts {
             if (type.flags & TypeFlags.IndexedAccess) {
                 return getIndexedAccessType(instantiateType((<IndexedAccessType>type).objectType, mapper), instantiateType((<IndexedAccessType>type).indexType, mapper));
             }
-            if (type.flags & TypeFlags.Promised) {
-                return getPromisedType(instantiateType((<IndexType>type).type, mapper)) || unknownType;
+            if (type.flags & TypeFlags.Awaited) {
+                return getAwaitedType(instantiateType((<IndexType>type).type, mapper)) || unknownType;
             }
             return type;
         }
@@ -9355,12 +9355,12 @@ namespace ts {
                         }
                     }
                 }
-                else if (target.flags & TypeFlags.Promised && source.flags & TypeFlags.Promised) {
-                    // A promised S is related to a promised T if S is related to T:
+                else if (target.flags & TypeFlags.Awaited && source.flags & TypeFlags.Awaited) {
+                    // A awaited S is related to a awaited T if S is related to T:
                     //
-                    //  S <: T ⇒ promised S <: promised T
+                    //  S <: T ⇒ awaited S <: awaited T
                     //
-                    if (result = isRelatedTo((<PromisedType>source).type, (<PromisedType>target).type, reportErrors)) {
+                    if (result = isRelatedTo((<AwaitedType>source).type, (<AwaitedType>target).type, reportErrors)) {
                         return result;
                     }
                 }
@@ -9411,15 +9411,15 @@ namespace ts {
                         }
                     }
                 }
-                else if (source.flags & TypeFlags.Promised) {
-                    // A promised S is related to T if promised C is related to T, where C is the
+                else if (source.flags & TypeFlags.Awaited) {
+                    // A awaited S is related to T if awaited C is related to T, where C is the
                     // constraint of S:
                     //
-                    //  S <: C ^ promised C <: T ⇒ promised S <: T
+                    //  S <: C ^ awaited C <: T ⇒ awaited S <: T
                     //
-                    const constraint = getConstraintOfType((<PromisedType>source).type);
+                    const constraint = getConstraintOfType((<AwaitedType>source).type);
                     if (constraint) {
-                        if (result = isRelatedTo(getPromisedType(constraint), target, reportErrors)) {
+                        if (result = isRelatedTo(getAwaitedType(constraint), target, reportErrors)) {
                             return result;
                         }
                     }
@@ -13033,7 +13033,7 @@ namespace ts {
 
                 const contextualReturnType = getContextualReturnType(func);
                 return functionFlags & FunctionFlags.Async
-                    ? contextualReturnType && getPromisedTypeOfPromise(contextualReturnType) // Async function
+                    ? contextualReturnType && getAwaitedTypeOfPromise(contextualReturnType) // Async function
                     : contextualReturnType; // Regular function
             }
             return undefined;
@@ -16764,8 +16764,8 @@ namespace ts {
             // creates a `Promise<T>` type where `T` is the promisedType argument
             const globalPromiseType = getGlobalPromiseType(/*reportErrors*/ true);
             if (globalPromiseType !== emptyGenericType) {
-                // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type
-                promisedType = getPromisedType(promisedType) || emptyObjectType;
+                // if the awaited type is itself a promise, get the underlying type; otherwise, fallback to the awaited type
+                promisedType = getAwaitedType(promisedType) || emptyObjectType;
                 return createTypeReference(<GenericType>globalPromiseType, [promisedType]);
             }
 
@@ -16804,7 +16804,7 @@ namespace ts {
                     // Promise/A+ compatible implementation will always assimilate any foreign promise, so the
                     // return type of the body should be unwrapped to its awaited type, which we will wrap in
                     // the native Promise<T> type later in this function.
-                    type = checkPromisedType(type, /*errorNode*/ func, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+                    type = checkAwaitedType(type, /*errorNode*/ func, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
                 }
             }
             else {
@@ -16879,7 +16879,7 @@ namespace ts {
                         type = checkIteratedTypeOrElementType(type, yieldExpression.expression, /*allowStringInput*/ false, (functionFlags & FunctionFlags.Async) !== 0);
                     }
                     if (functionFlags & FunctionFlags.Async) {
-                        type = checkPromisedType(type, expr, yieldExpression.asteriskToken
+                        type = checkAwaitedType(type, expr, yieldExpression.asteriskToken
                             ? Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
                             : Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
                     }
@@ -16930,7 +16930,7 @@ namespace ts {
                         // Promise/A+ compatible implementation will always assimilate any foreign promise, so the
                         // return type of the body should be unwrapped to its awaited type, which should be wrapped in
                         // the native Promise<T> type by the caller.
-                        type = checkPromisedType(type, func, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+                        type = checkAwaitedType(type, func, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
                     }
                     if (type.flags & TypeFlags.Never) {
                         hasReturnOfTypeNever = true;
@@ -17070,14 +17070,14 @@ namespace ts {
 
             const functionFlags = getFunctionFlags(node);
             const returnTypeNode = getEffectiveReturnTypeNode(node);
-            const returnOrPromisedType = returnTypeNode &&
+            const returnOrAwaitedType = returnTypeNode &&
                 ((functionFlags & FunctionFlags.AsyncGenerator) === FunctionFlags.Async ?
                     checkAsyncFunctionReturnType(node) : // Async function
                     getTypeFromTypeNode(returnTypeNode)); // AsyncGenerator function, Generator function, or normal function
 
             if ((functionFlags & FunctionFlags.Generator) === 0) { // Async function or normal function
                 // return is not necessary in the body of generators
-                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrAwaitedType);
             }
 
             if (node.body) {
@@ -17097,16 +17097,16 @@ namespace ts {
                     // From within an async function you can return either a non-promise value or a promise. Any
                     // Promise/A+ compatible implementation will always assimilate any foreign promise, so we
                     // should not be checking assignability of a promise to the return type. Instead, we need to
-                    // check assignability of the awaited type of the expression body against the promised type of
+                    // check assignability of the awaited type of the expression body against the awaited type of
                     // its return type annotation.
                     const exprType = checkExpression(<Expression>node.body);
-                    if (returnOrPromisedType) {
+                    if (returnOrAwaitedType) {
                         if ((functionFlags & FunctionFlags.AsyncGenerator) === FunctionFlags.Async) { // Async function
-                            const awaitedType = checkPromisedType(exprType, node.body, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
-                            checkTypeAssignableTo(awaitedType, returnOrPromisedType, node.body);
+                            const awaitedType = checkAwaitedType(exprType, node.body, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+                            checkTypeAssignableTo(awaitedType, returnOrAwaitedType, node.body);
                         }
                         else { // Normal function
-                            checkTypeAssignableTo(exprType, returnOrPromisedType, node.body);
+                            checkTypeAssignableTo(exprType, returnOrAwaitedType, node.body);
                         }
                     }
                 }
@@ -17219,7 +17219,7 @@ namespace ts {
             }
 
             const operandType = checkExpression(node.expression);
-            return checkPromisedType(operandType, node, Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+            return checkAwaitedType(operandType, node, Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
         }
 
         function checkPrefixUnaryExpression(node: PrefixUnaryExpression): Type {
@@ -17869,7 +17869,7 @@ namespace ts {
                         if (nodeIsYieldStar) {
                             checkTypeAssignableTo(
                                 functionFlags & FunctionFlags.Async
-                                    ? getPromisedType(expressionElementType, node.expression, Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)
+                                    ? getAwaitedType(expressionElementType, node.expression, Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)
                                     : expressionElementType,
                                 signatureElementType,
                                 node.expression,
@@ -17878,7 +17878,7 @@ namespace ts {
                         else {
                             checkTypeAssignableTo(
                                 functionFlags & FunctionFlags.Async
-                                    ? getPromisedType(expressionType, node.expression, Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)
+                                    ? getAwaitedType(expressionType, node.expression, Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)
                                     : expressionType,
                                 signatureElementType,
                                 node.expression,
@@ -19322,109 +19322,109 @@ namespace ts {
         }
 
         /**
-         * Gets or creates a `promised T` type for a type variable.
+         * Gets or creates a `awaited T` type for a type variable.
          *
-         * The "promised type" of a type variable cannot be determined until it is instantiated. As
+         * The "awaited type" of a type variable cannot be determined until it is instantiated. As
          * a result, a `PromisedType` for the type variable is created that can be instantiated
          * or related later.
          */
-        function getPromisedTypeForGenericType(type: TypeVariable | UnionOrIntersectionType) {
-            if (!type.resolvedPromisedType) {
-                type.resolvedPromisedType = <PromisedType>createType(TypeFlags.Promised);
-                type.resolvedPromisedType.type = type;
+        function getAwaitedTypeForGenericType(type: TypeVariable | UnionOrIntersectionType) {
+            if (!type.resolvedAwaitedType) {
+                type.resolvedAwaitedType = <AwaitedType>createType(TypeFlags.Awaited);
+                type.resolvedAwaitedType.type = type;
             }
-            return type.resolvedPromisedType;
+            return type.resolvedAwaitedType;
         }
 
         /**
-         * Gets the "promised type" of a type.
+         * Gets the "awaited type" of a type.
          *
-         * The "promised type" of an expression is its "fulfillment type" if the expression is a
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
          * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
          * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
          * non-promise type is found.
          *
-         * This is used to reflect the runtime behavior of the `await` keyword and the `promised T`
+         * This is used to reflect the runtime behavior of the `await` keyword and the `awaited T`
          * type.
          */
-        function getPromisedType(type: Type): Type | undefined;
+        function getAwaitedType(type: Type): Type | undefined;
         /**
-         * Gets the "promised type" of a type.
+         * Gets the "awaited type" of a type.
          *
-         * The "promised type" of an expression is its "fulfillment type" if the expression is a
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
          * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
          * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
          * non-promise type is found.
          *
-         * This is used to reflect the runtime behavior of the `await` keyword and the `promised T`
+         * This is used to reflect the runtime behavior of the `await` keyword and the `awaited T`
          * type.
          */
-        function getPromisedType(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage): Type | undefined;
+        function getAwaitedType(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage): Type | undefined;
         /**
-         * Gets the "promised type" of a type.
+         * Gets the "awaited type" of a type.
          *
-         * The "promised type" of an expression is its "fulfillment type" if the expression is a
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
          * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
          * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
          * non-promise type is found.
          *
-         * This is used to reflect the runtime behavior of the `await` keyword and the `promised T`
+         * This is used to reflect the runtime behavior of the `await` keyword and the `awaited T`
          * type.
          */
-        function getPromisedType(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
-            // For a union, get a union of the promised types of each constituent.
+        function getAwaitedType(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
+            // For a union, get a union of the awaited types of each constituent.
             //
             // For example:
             //
             //   number | string          -> number | string
             //   number | Promise<string> -> number | string
-            //   T | string               -> promised T | string
-            //   T | Promise<string>      -> promised T | string
-            //   T | Promise<never>       -> promised T
-            //   T | U                    -> promised T | promised U
+            //   T | string               -> awaited T | string
+            //   T | Promise<string>      -> awaited T | string
+            //   T | Promise<never>       -> awaited T
+            //   T | U                    -> awaited T | awaited U
             //
             // We treat intersection types as any other value.
             //
             // For example:
             //
-            //   A & B          -> promised (A & B)
-            //   A & Promise<B> -> promised B
+            //   A & B          -> awaited (A & B)
+            //   A & Promise<B> -> awaited B
             //
-            return mapType(type, errorNode ? constituentType => getPromisedTypeWorker(constituentType, errorNode, diagnosticMessage) : getPromisedTypeWorker);
+            return mapType(type, errorNode ? constituentType => getAwaitedTypeWorker(constituentType, errorNode, diagnosticMessage) : getAwaitedTypeWorker);
         }
 
-        function getPromisedTypeWorker(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
-            // If the type is already a promised type, return it.
+        function getAwaitedTypeWorker(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
+            // If the type is already a awaited type, return it.
             //
             // For example:
             //
-            //   promised T -> promised T
+            //   awaited T -> awaited T
             //
-            if (type.flags & TypeFlags.Promised) {
+            if (type.flags & TypeFlags.Awaited) {
                 return type;
             }
 
-            // We cannot resolve the promised type for a type variable until it is instantiated. As
-            // such, we create a `promised T` type that can either be instantiated or related later.
+            // We cannot resolve the awaited type for a type variable until it is instantiated. As
+            // such, we create a `awaited T` type that can either be instantiated or related later.
             //
             // For example:
             //
-            //   T -> promised T
+            //   T -> awaited T
             //
             if (type.flags & TypeFlags.TypeVariable) {
-                return getPromisedTypeForGenericType(<TypeVariable>type);
+                return getAwaitedTypeForGenericType(<TypeVariable>type);
             }
 
             const typeAsAwaitable = <PromiseOrAwaitableType>type;
 
             // Use the cached type if already computed.
-            if (typeAsAwaitable.promisedType) {
-                return typeAsAwaitable.promisedType;
+            if (typeAsAwaitable.awaitedType) {
+                return typeAsAwaitable.awaitedType;
             }
 
             const fulfillmentType = getFulfillmentTypeOfPromise(type);
             if (fulfillmentType) {
-                if (type === fulfillmentType || promisedTypeStack.lastIndexOf(fulfillmentType) >= 0) {
+                if (type === fulfillmentType || awaitedTypeStack.lastIndexOf(fulfillmentType) >= 0) {
                     // Verify that we don't have a bad actor in the form of a promise whose
                     // "fulfillment type" is the same as the promise, or a mutually recursive
                     // promise. If so, we return `undefined` as we cannot guess the shape. If this
@@ -19440,7 +19440,7 @@ namespace ts {
                     //  }
                     //
                     // The above interface will pass the PromiseLike check and return a
-                    // promised type of `BadPromise`. Since this is a self reference, we
+                    // awaited type of `BadPromise`. Since this is a self reference, we
                     // don't want to keep recursing ad infinitum.
                     //
                     // An example of a bad actor in the form of a mutually-recursive
@@ -19466,10 +19466,10 @@ namespace ts {
 
                 // Keep track of the type we're about to unwrap to avoid bad recursive promise types.
                 // See the comments above for more information.
-                promisedTypeStack.push(type);
-                const promisedType = getPromisedType(fulfillmentType, errorNode, diagnosticMessage);
-                promisedTypeStack.pop();
-                return typeAsAwaitable.promisedType = promisedType;
+                awaitedTypeStack.push(type);
+                const awaitedType = getAwaitedType(fulfillmentType, errorNode, diagnosticMessage);
+                awaitedTypeStack.pop();
+                return typeAsAwaitable.awaitedType = awaitedType;
             }
 
             // The type was not a promise, so it could not be unwrapped any further.
@@ -19495,59 +19495,59 @@ namespace ts {
                 return undefined;
             }
 
-            return typeAsAwaitable.promisedType = type;
+            return typeAsAwaitable.awaitedType = type;
         }
 
         /**
-         * Checks the "promised type" of a type.
+         * Checks the "awaited type" of a type.
          *
-         * The "promised type" of an expression is its "fulfillment type" if the expression is a
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
          * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
          * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
          * non-promise type is found.
          *
          * If `type` is not Promise-like, `type` is returned.
-         * If the "promised type" of `type` is a non-promise "thenable", `unknownType` is returned.
+         * If the "awaited type" of `type` is a non-promise "thenable", `unknownType` is returned.
          */
-        function checkPromisedType(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage): Type {
-            return getPromisedType(type, errorNode, diagnosticMessage) || unknownType;
+        function checkAwaitedType(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage): Type {
+            return getAwaitedType(type, errorNode, diagnosticMessage) || unknownType;
         }
 
         /**
-         * Gets the "promised type" of a Promise-like type.
+         * Gets the "awaited type" of a Promise-like type.
          *
-         * The "promised type" of an expression is its "fulfillment type" if the expression is a
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
          * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
          * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
          * non-promise type is found.
          *
          * If `type` is not Promise-like, `undefined` is returned.
          */
-        function getPromisedTypeOfPromise(type: Type): Type | undefined;
+        function getAwaitedTypeOfPromise(type: Type): Type | undefined;
         /**
-         * Gets the "promised type" of a Promise-like type.
+         * Gets the "awaited type" of a Promise-like type.
          *
-         * The "promised type" of an expression is its "fulfillment type" if the expression is a
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
          * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
          * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
          * non-promise type is found.
          *
          * If `type` is not Promise-like, `undefined` is returned.
          */
-        function getPromisedTypeOfPromise(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage): Type | undefined;
+        function getAwaitedTypeOfPromise(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage): Type | undefined;
         /**
-         * Gets the "promised type" of a Promise-like type.
+         * Gets the "awaited type" of a Promise-like type.
          *
-         * The "promised type" of an expression is its "fulfillment type" if the expression is a
+         * The "awaited type" of an expression is its "fulfillment type" if the expression is a
          * Promise-like type; otherwise, it is the type of the expression. If the "fulfillment
          * type" is itself a Promise-like, the "fulfillment type" is recursively unwrapped until a
          * non-promise type is found.
          *
          * If `type` is not Promise-like, `undefined` is returned.
          */
-        function getPromisedTypeOfPromise(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
-            const promisedType = getFulfillmentTypeOfPromise(type, errorNode);
-            return promisedType && getPromisedType(promisedType, errorNode, diagnosticMessage);
+        function getAwaitedTypeOfPromise(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
+            const fulfillmentType = getFulfillmentTypeOfPromise(type, errorNode);
+            return fulfillmentType && getAwaitedType(fulfillmentType, errorNode, diagnosticMessage);
         }
 
         /**
@@ -19654,7 +19654,7 @@ namespace ts {
             }
 
             // Get and return the awaited type of the return type.
-            return checkPromisedType(returnType, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+            return checkAwaitedType(returnType, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
         }
 
         /** Check a decorator */
@@ -19919,10 +19919,10 @@ namespace ts {
 
             const returnTypeNode = getEffectiveReturnTypeNode(node);
             if ((functionFlags & FunctionFlags.Generator) === 0) { // Async function or normal function
-                const returnOrPromisedType = returnTypeNode && (functionFlags & FunctionFlags.Async
+                const returnOrAwaitedType = returnTypeNode && (functionFlags & FunctionFlags.Async
                     ? checkAsyncFunctionReturnType(node) // Async function
                     : getTypeFromTypeNode(returnTypeNode)); // normal function
-                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrAwaitedType);
             }
 
             if (produceDiagnostics && !returnTypeNode) {
@@ -21018,7 +21018,7 @@ namespace ts {
 
             // For an async iterator, we must get the awaited type of the return type.
             if (isAsyncIterator) {
-                nextResult = getPromisedTypeOfPromise(nextResult, errorNode, Diagnostics.The_type_returned_by_the_next_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property);
+                nextResult = getAwaitedTypeOfPromise(nextResult, errorNode, Diagnostics.The_type_returned_by_the_next_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property);
                 if (isTypeAny(nextResult)) {
                     return undefined;
                 }
@@ -21109,13 +21109,13 @@ namespace ts {
                     }
                     else if (getEffectiveReturnTypeNode(func) || isGetAccessorWithAnnotatedSetAccessor(func)) {
                         if (functionFlags & FunctionFlags.Async) { // Async function
-                            const promisedType = getFulfillmentTypeOfPromise(returnType);
-                            const awaitedType = checkPromisedType(exprType, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
-                            if (promisedType) {
-                                // If the function has a return type, but promisedType is
+                            const fulfillmentType = getFulfillmentTypeOfPromise(returnType);
+                            const awaitedType = checkAwaitedType(exprType, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+                            if (fulfillmentType) {
+                                // If the function has a return type, but fulfillmentType is
                                 // undefined, an error will be reported in checkAsyncFunctionReturnType
                                 // so we don't need to report one here.
-                                checkTypeAssignableTo(awaitedType, promisedType, node);
+                                checkTypeAssignableTo(awaitedType, fulfillmentType, node);
                             }
                         }
                         else {
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 9868e96ee3c..42037d5d2b5 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -730,7 +730,7 @@ namespace ts {
         return <ThisTypeNode>createSynthesizedNode(SyntaxKind.ThisType);
     }
 
-    export function createTypeOperatorNode(type: TypeNode, operator: SyntaxKind.KeyOfKeyword | SyntaxKind.PromisedKeyword) {
+    export function createTypeOperatorNode(type: TypeNode, operator: SyntaxKind.KeyOfKeyword | SyntaxKind.AwaitedKeyword) {
         const node = createSynthesizedNode(SyntaxKind.TypeOperator) as TypeOperatorNode;
         node.operator = operator;
         node.type = parenthesizeElementTypeMember(type);
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 3bd051fb6e2..db95a562d42 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -2782,7 +2782,7 @@ namespace ts {
             return type;
         }
 
-        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.PromisedKeyword) {
+        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.AwaitedKeyword) {
             const node = <TypeOperatorNode>createNode(SyntaxKind.TypeOperator);
             parseExpected(operator);
             node.operator = operator;
@@ -2794,7 +2794,7 @@ namespace ts {
             const keyword = token();
             switch (keyword) {
                 case SyntaxKind.KeyOfKeyword:
-                case SyntaxKind.PromisedKeyword:
+                case SyntaxKind.AwaitedKeyword:
                     return parseTypeOperator(keyword);
             }
             return parseArrayTypeOrHigher();
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index d31ebd868c8..2eb9e1a75be 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -62,6 +62,7 @@ namespace ts {
         "abstract": SyntaxKind.AbstractKeyword,
         "any": SyntaxKind.AnyKeyword,
         "as": SyntaxKind.AsKeyword,
+        "awaited": SyntaxKind.AwaitedKeyword,
         "boolean": SyntaxKind.BooleanKeyword,
         "break": SyntaxKind.BreakKeyword,
         "case": SyntaxKind.CaseKeyword,
@@ -104,7 +105,6 @@ namespace ts {
         "package": SyntaxKind.PackageKeyword,
         "private": SyntaxKind.PrivateKeyword,
         "protected": SyntaxKind.ProtectedKeyword,
-        "promised": SyntaxKind.PromisedKeyword,
         "public": SyntaxKind.PublicKeyword,
         "readonly": SyntaxKind.ReadonlyKeyword,
         "require": SyntaxKind.RequireKeyword,
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index b6279dcbc11..08db779d7be 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -190,7 +190,7 @@ namespace ts {
         ModuleKeyword,
         NamespaceKeyword,
         NeverKeyword,
-        PromisedKeyword,
+        AwaitedKeyword,
         ReadonlyKeyword,
         RequireKeyword,
         NumberKeyword,
@@ -973,7 +973,7 @@ namespace ts {
 
     export interface TypeOperatorNode extends TypeNode {
         kind: SyntaxKind.TypeOperator;
-        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.PromisedKeyword;
+        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.AwaitedKeyword;
         type: TypeNode;
     }
 
@@ -3141,7 +3141,7 @@ namespace ts {
         Intersection            = 1 << 17,  // Intersection (T & U)
         Index                   = 1 << 18,  // keyof T
         IndexedAccess           = 1 << 19,  // T[K]
-        Promised                = 1 << 20,  // promised T
+        Awaited                 = 1 << 20,  // awaited T
         /* @internal */
         FreshLiteral            = 1 << 21,  // Fresh literal type
         /* @internal */
@@ -3171,12 +3171,12 @@ namespace ts {
         EnumLike = Enum | EnumLiteral,
         UnionOrIntersection = Union | Intersection,
         StructuredType = Object | Union | Intersection,
-        StructuredOrTypeVariable = StructuredType | TypeParameter | Index | IndexedAccess | Promised,
-        TypeVariable = TypeParameter | IndexedAccess | Promised,
+        StructuredOrTypeVariable = StructuredType | TypeParameter | Index | IndexedAccess | Awaited,
+        TypeVariable = TypeParameter | IndexedAccess | Awaited,
 
         // 'Narrowable' types are types where narrowing actually narrows.
         // This *should* be every type other than null, undefined, void, and never
-        Narrowable = Any | StructuredType | TypeParameter | Index | IndexedAccess | StringLike | NumberLike | BooleanLike | ESSymbol | NonPrimitive | Promised,
+        Narrowable = Any | StructuredType | TypeParameter | Index | IndexedAccess | StringLike | NumberLike | BooleanLike | ESSymbol | NonPrimitive | Awaited,
         NotUnionOrUnit = Any | ESSymbol | Object | NonPrimitive,
         /* @internal */
         RequiresWidening = ContainsWideningType | ContainsObjectLiteral,
@@ -3299,7 +3299,7 @@ namespace ts {
         /* @internal */
         couldContainTypeVariables: boolean;
         /* @internal */
-        resolvedPromisedType: PromisedType;
+        resolvedAwaitedType: AwaitedType;
     }
 
     export interface UnionType extends UnionOrIntersectionType { }
@@ -3364,7 +3364,7 @@ namespace ts {
     /* @internal */
     export interface PromiseOrAwaitableType extends ObjectType, UnionType {
         fulfillmentType?: Type;     // Type of `value` parameter of `onfulfilled` callback.
-        promisedType?: Type;        // The "fulfillment type" if a Promise-like, otherwise this type.
+        awaitedType?: Type;         // The "fulfillment type" if a Promise-like, otherwise this type.
     }
 
     /* @internal */
@@ -3378,7 +3378,7 @@ namespace ts {
         /* @internal */
         resolvedIndexType: IndexType;
         /* @internal */
-        resolvedPromisedType: PromisedType;
+        resolvedAwaitedType: AwaitedType;
     }
 
     // Type parameters (TypeFlags.TypeParameter)
@@ -3409,8 +3409,8 @@ namespace ts {
         type: TypeVariable | UnionOrIntersectionType;
     }
 
-    // promised T types (TypeFlags.Promised)
-    export interface PromisedType extends Type {
+    // awaited T types (TypeFlags.Awaited)
+    export interface AwaitedType extends Type {
         type: TypeVariable;
     }
 
diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index 494e09d5022..008236b052e 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -197,7 +197,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<TAll>(values: Iterable<TAll>): Promise<(promised TAll)[]>;
+    all<TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -205,7 +205,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T>(values: Iterable<T>): Promise<promised T>;
+    race<T>(values: Iterable<T>): Promise<awaited T>;
 }
 
 declare namespace Reflect {
diff --git a/src/lib/es2015.promise.d.ts b/src/lib/es2015.promise.d.ts
index af6eaf02126..853c0cf8b0b 100644
--- a/src/lib/es2015.promise.d.ts
+++ b/src/lib/es2015.promise.d.ts
@@ -18,7 +18,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8, promised T9, promised T10]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9, awaited T10]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -26,7 +26,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8, promised T9]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -34,7 +34,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -42,7 +42,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7]>;
+    all<T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -50,7 +50,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6]>;
+    all<T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -58,7 +58,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5]>;
+    all<T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -66,7 +66,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[promised T1, promised T2, promised T3, promised T4]>;
+    all<T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -74,7 +74,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2, T3>(values: [T1, T2, T3]): Promise<[promised T1, promised T2, promised T3]>;
+    all<T1, T2, T3>(values: [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -82,7 +82,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T1, T2>(values: [T1, T2]): Promise<[promised T1, promised T2]>;
+    all<T1, T2>(values: [T1, T2]): Promise<[awaited T1, awaited T2]>;
 
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -90,7 +90,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<T>(values: T[]): Promise<(promised T)[]>;
+    all<T>(values: T[]): Promise<(awaited T)[]>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -98,7 +98,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<promised T1 | promised T2 | promised T3 | promised T4 | promised T5 | promised T6 | promised T7 | promised T8 | promised T9 | promised T10>;
+    race<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5 | awaited T6 | awaited T7 | awaited T8 | awaited T9 | awaited T10>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -106,7 +106,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<promised T1 | promised T2 | promised T3 | promised T4 | promised T5 | promised T6 | promised T7 | promised T8 | promised T9>;
+    race<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5 | awaited T6 | awaited T7 | awaited T8 | awaited T9>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -114,7 +114,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<promised T1 | promised T2 | promised T3 | promised T4 | promised T5 | promised T6 | promised T7 | promised T8>;
+    race<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5 | awaited T6 | awaited T7 | awaited T8>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -122,7 +122,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<promised T1 | promised T2 | promised T3 | promised T4 | promised T5 | promised T6 | promised T7>;
+    race<T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5 | awaited T6 | awaited T7>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -130,7 +130,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<promised T1 | promised T2 | promised T3 | promised T4 | promised T5 | promised T6>;
+    race<T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5 | awaited T6>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -138,7 +138,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<promised T1 | promised T2 | promised T3 | promised T4 | promised T5>;
+    race<T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4 | awaited T5>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -146,7 +146,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<promised T1 | promised T2 | promised T3 | promised T4>;
+    race<T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<awaited T1 | awaited T2 | awaited T3 | awaited T4>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -154,7 +154,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2, T3>(values: [T1, T2, T3]): Promise<promised T1 | promised T2 | promised T3>;
+    race<T1, T2, T3>(values: [T1, T2, T3]): Promise<awaited T1 | awaited T2 | awaited T3>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -162,7 +162,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T1, T2>(values: [T1, T2]): Promise<promised T1 | promised T2>;
+    race<T1, T2>(values: [T1, T2]): Promise<awaited T1 | awaited T2>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -170,7 +170,7 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T>(values: T[]): Promise<promised T>;
+    race<T>(values: T[]): Promise<awaited T>;
 
     /**
      * Creates a new rejected promise for the provided reason.
@@ -184,14 +184,14 @@ interface PromiseConstructor {
      * @param reason The reason the promise was rejected.
      * @returns A new rejected Promise.
      */
-    reject<T>(reason: any): Promise<promised T>;
+    reject<T>(reason: any): Promise<awaited T>;
 
     /**
      * Creates a new resolved promise for the provided value.
      * @param value A promise.
      * @returns A promise whose internal state matches the provided promise.
      */
-    resolve<T>(value: T): Promise<promised T>;
+    resolve<T>(value: T): Promise<awaited T>;
 
     /**
      * Creates a new resolved promise .
diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
index 96e9c0947a5..e5845571a4f 100644
--- a/src/lib/es5.d.ts
+++ b/src/lib/es5.d.ts
@@ -1259,7 +1259,7 @@ interface PromiseLike<T> {
      * @param onrejected The callback to execute when the Promise is rejected.
      * @returns A Promise for the completion of which ever callback is executed.
      */
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: promised T) => TResult1) | undefined | null, onrejected?: ((reason: any) => TResult2) | undefined | null): PromiseLike<promised TResult1 | promised TResult2>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: awaited T) => TResult1) | undefined | null, onrejected?: ((reason: any) => TResult2) | undefined | null): PromiseLike<awaited TResult1 | awaited TResult2>;
 }
 
 /**
@@ -1272,14 +1272,14 @@ interface Promise<T> {
      * @param onrejected The callback to execute when the Promise is rejected.
      * @returns A Promise for the completion of which ever callback is executed.
      */
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: promised T) => TResult1) | undefined | null, onrejected?: ((reason: any) => TResult2) | undefined | null): Promise<promised TResult1 | promised TResult2>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: awaited T) => TResult1) | undefined | null, onrejected?: ((reason: any) => TResult2) | undefined | null): Promise<awaited TResult1 | awaited TResult2>;
 
     /**
      * Attaches a callback for only the rejection of the Promise.
      * @param onrejected The callback to execute when the Promise is rejected.
      * @returns A Promise for the completion of the callback.
      */
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult) | undefined | null): Promise<promised T | promised TResult>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult) | undefined | null): Promise<awaited T | awaited TResult>;
 }
 
 interface ArrayLike<T> {
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es2017.types b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es2017.types
index 1394abfb7d4..dbf81dbba27 100644
--- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es2017.types
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es2017.types
@@ -6,9 +6,9 @@ class C {
 >method : () => void
 
       var fn = async () => await this;      
->fn : () => Promise<promised this>
->async () => await this : () => Promise<promised this>
->await this : promised this
+>fn : () => Promise<awaited this>
+>async () => await this : () => Promise<awaited this>
+>await this : awaited this
 >this : this
    }
 }
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es5.types b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es5.types
index 49a195dd953..799c77e77c7 100644
--- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es5.types
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es5.types
@@ -6,9 +6,9 @@ class C {
 >method : () => void
 
       var fn = async () => await this;
->fn : () => Promise<promised this>
->async () => await this : () => Promise<promised this>
->await this : promised this
+>fn : () => Promise<awaited this>
+>async () => await this : () => Promise<awaited this>
+>await this : awaited this
 >this : this
    }
 }
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types
index 095bf35d5fb..bfab27d8b38 100644
--- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types
@@ -6,9 +6,9 @@ class C {
 >method : () => void
 
       var fn = async () => await this;      
->fn : () => Promise<promised this>
->async () => await this : () => Promise<promised this>
->await this : promised this
+>fn : () => Promise<awaited this>
+>async () => await this : () => Promise<awaited this>
+>await this : awaited this
 >this : this
    }
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
index d16a87ece81..a31727a47dd 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
+++ b/tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
@@ -6,8 +6,8 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(10,23): error TS1055: Type 'typeof Thenable' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
   Type 'Thenable' is not assignable to type 'PromiseLike<T>'.
     Types of property 'then' are incompatible.
-      Type '() => void' is not assignable to type '<TResult1 = T, TResult2 = never>(onfulfilled?: (value: promised T) => TResult1, onrejected?: (reason: any) => TResult2) => PromiseLike<promised TResult1 | promised TResult2>'.
-        Type 'void' is not assignable to type 'PromiseLike<promised TResult1 | promised TResult2>'.
+      Type '() => void' is not assignable to type '<TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2) => PromiseLike<awaited TResult1 | awaited TResult2>'.
+        Type 'void' is not assignable to type 'PromiseLike<awaited TResult1 | awaited TResult2>'.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(17,16): error TS1058: The return type of an async function must either be a valid promise or must not contain a callable 'then' member.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(23,25): error TS1320: Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member.
 
@@ -37,8 +37,8 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1
 !!! error TS1055: Type 'typeof Thenable' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
 !!! error TS1055:   Type 'Thenable' is not assignable to type 'PromiseLike<T>'.
 !!! error TS1055:     Types of property 'then' are incompatible.
-!!! error TS1055:       Type '() => void' is not assignable to type '<TResult1 = T, TResult2 = never>(onfulfilled?: (value: promised T) => TResult1, onrejected?: (reason: any) => TResult2) => PromiseLike<promised TResult1 | promised TResult2>'.
-!!! error TS1055:         Type 'void' is not assignable to type 'PromiseLike<promised TResult1 | promised TResult2>'.
+!!! error TS1055:       Type '() => void' is not assignable to type '<TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2) => PromiseLike<awaited TResult1 | awaited TResult2>'.
+!!! error TS1055:         Type 'void' is not assignable to type 'PromiseLike<awaited TResult1 | awaited TResult2>'.
     async function fn7() { return; } // valid: Promise<void>
     async function fn8() { return 1; } // valid: Promise<number>
     async function fn9() { return null; } // valid: Promise<any>
diff --git a/tests/baselines/reference/asyncFunctionReturnType.types b/tests/baselines/reference/asyncFunctionReturnType.types
index 6d0445d1a99..ad402c6c40f 100644
--- a/tests/baselines/reference/asyncFunctionReturnType.types
+++ b/tests/baselines/reference/asyncFunctionReturnType.types
@@ -53,9 +53,9 @@ async function fIndexedTypeForPromiseOfStringProp(obj: Obj): Promise<Obj["string
 
     return Promise.resolve(obj.stringProp);
 >Promise.resolve(obj.stringProp) : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >obj.stringProp : string
 >obj : Obj
 >stringProp : string
@@ -70,9 +70,9 @@ async function fIndexedTypeForExplicitPromiseOfStringProp(obj: Obj): Promise<Obj
 
     return Promise.resolve<Obj["stringProp"]>(obj.stringProp);
 >Promise.resolve<Obj["stringProp"]>(obj.stringProp) : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Obj : Obj
 >obj.stringProp : string
 >obj : Obj
@@ -101,9 +101,9 @@ async function fIndexedTypeForPromiseOfAnyProp(obj: Obj): Promise<Obj["anyProp"]
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve(obj.anyProp) : Promise<any>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >obj.anyProp : any
 >obj : Obj
 >anyProp : any
@@ -118,9 +118,9 @@ async function fIndexedTypeForExplicitPromiseOfAnyProp(obj: Obj): Promise<Obj["a
 
     return Promise.resolve<Obj["anyProp"]>(obj.anyProp);
 >Promise.resolve<Obj["anyProp"]>(obj.anyProp) : Promise<any>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Obj : Obj
 >obj.anyProp : any
 >obj : Obj
@@ -153,9 +153,9 @@ async function fGenericIndexedTypeForPromiseOfStringProp<TObj extends Obj>(obj:
 
     return Promise.resolve(obj.stringProp);
 >Promise.resolve(obj.stringProp) : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >obj.stringProp : string
 >obj : TObj
 >stringProp : string
@@ -171,10 +171,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfStringProp<TObj extends Ob
 >TObj : TObj
 
     return Promise.resolve<TObj["stringProp"]>(obj.stringProp);
->Promise.resolve<TObj["stringProp"]>(obj.stringProp) : Promise<promised TObj["stringProp"]>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve<TObj["stringProp"]>(obj.stringProp) : Promise<awaited TObj["stringProp"]>
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >TObj : TObj
 >obj.stringProp : string
 >obj : TObj
@@ -207,9 +207,9 @@ async function fGenericIndexedTypeForPromiseOfAnyProp<TObj extends Obj>(obj: TOb
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve(obj.anyProp) : Promise<any>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >obj.anyProp : any
 >obj : TObj
 >anyProp : any
@@ -225,10 +225,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
 >TObj : TObj
 
     return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
->Promise.resolve<TObj["anyProp"]>(obj.anyProp) : Promise<promised TObj["anyProp"]>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve<TObj["anyProp"]>(obj.anyProp) : Promise<awaited TObj["anyProp"]>
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >TObj : TObj
 >obj.anyProp : any
 >obj : TObj
@@ -270,10 +270,10 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
 >K : K
 
     return Promise.resolve(obj[key]);
->Promise.resolve(obj[key]) : Promise<promised TObj[K]>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve(obj[key]) : Promise<awaited TObj[K]>
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >obj[key] : TObj[K]
 >obj : TObj
 >key : K
@@ -294,10 +294,10 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
 >K : K
 
     return Promise.resolve<TObj[K]>(obj[key]);
->Promise.resolve<TObj[K]>(obj[key]) : Promise<promised TObj[K]>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve<TObj[K]>(obj[key]) : Promise<awaited TObj[K]>
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >TObj : TObj
 >K : K
 >obj[key] : TObj[K]
diff --git a/tests/baselines/reference/promised.js b/tests/baselines/reference/awaited.js
similarity index 83%
rename from tests/baselines/reference/promised.js
rename to tests/baselines/reference/awaited.js
index 17393597c4d..0880ec68c46 100644
--- a/tests/baselines/reference/promised.js
+++ b/tests/baselines/reference/awaited.js
@@ -1,4 +1,4 @@
-//// [promised.ts]
+//// [awaited.ts]
 // simple
 declare const p0: Promise<number>;
 p0.then(x => x);
@@ -70,8 +70,8 @@ async function f6<U>(u: Promise<Promise<U>>) {
 
 // assignability
 let v0: number;
-let v1: promised number;
-let v2: promised Promise<number>;
+let v1: awaited number;
+let v2: awaited Promise<number>;
 v0 = v1;
 v0 = v2;
 v1 = v0;
@@ -80,21 +80,21 @@ v2 = v0;
 v2 = v1;
 
 function f7<U>() {
-    let v0: promised U;
-    let v1: promised Promise<U>;
+    let v0: awaited U;
+    let v1: awaited Promise<U>;
     v0 = v1;
     v1 = v0;
 }
 
 async function f8<U>() {
     let pu: Promise<U>;
-    let v0: promised U;
-    let v1: promised Promise<U>;
+    let v0: awaited U;
+    let v1: awaited Promise<U>;
     v0 = await pu;
     v1 = await pu;
 }
 
-//// [promised.js]
+//// [awaited.js]
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -188,21 +188,21 @@ function f8() {
 }
 
 
-//// [promised.d.ts]
+//// [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<promised U>;
-declare function f1<U, V>(u: U, v: V): Promise<(promised U) | (promised V)>;
-declare function f2<U>(u: U): Promise<promised U>;
-declare function f3<U, V>(u: U, v: V): Promise<(promised U) | (promised V)>;
-declare function f4<U, V>(u: U, v: V): Promise<(promised U) | (promised V)>;
-declare function f5<U>(u: Promise<U>): Promise<promised U>;
-declare function f6<U>(u: Promise<Promise<U>>): Promise<promised U>;
+declare function f0<U>(u: U): Promise<awaited U>;
+declare function f1<U, V>(u: U, v: V): Promise<(awaited U) | (awaited V)>;
+declare function f2<U>(u: U): Promise<awaited U>;
+declare function f3<U, V>(u: U, v: V): Promise<(awaited U) | (awaited V)>;
+declare function f4<U, V>(u: U, v: V): Promise<(awaited U) | (awaited V)>;
+declare function f5<U>(u: Promise<U>): Promise<awaited U>;
+declare function f6<U>(u: Promise<Promise<U>>): Promise<awaited U>;
 declare let v0: number;
-declare let v1: promised number;
-declare let v2: promised Promise<number>;
+declare let v1: awaited number;
+declare let v2: awaited Promise<number>;
 declare function f7<U>(): void;
 declare function f8<U>(): Promise<void>;
diff --git a/tests/baselines/reference/awaited.symbols b/tests/baselines/reference/awaited.symbols
new file mode 100644
index 00000000000..440bd0895ce
--- /dev/null
+++ b/tests/baselines/reference/awaited.symbols
@@ -0,0 +1,406 @@
+=== tests/cases/conformance/types/awaited/awaited.ts ===
+// simple
+declare const p0: Promise<number>;
+>p0 : Symbol(p0, Decl(awaited.ts, 1, 13))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+p0.then(x => x);
+>p0.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p0 : Symbol(p0, Decl(awaited.ts, 1, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 2, 8))
+>x : Symbol(x, Decl(awaited.ts, 2, 8))
+
+declare const p1: Promise<Promise<number>>;
+>p1 : Symbol(p1, Decl(awaited.ts, 4, 13))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+p1.then(x => x);
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(awaited.ts, 4, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 5, 8))
+>x : Symbol(x, Decl(awaited.ts, 5, 8))
+
+declare const p2: Promise<number | Promise<number>>;
+>p2 : Symbol(p2, Decl(awaited.ts, 7, 13))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+p2.then(x => x);
+>p2.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p2 : Symbol(p2, Decl(awaited.ts, 7, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 8, 8))
+>x : Symbol(x, Decl(awaited.ts, 8, 8))
+
+// generics
+declare const f: boolean;
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+
+declare function makePromise<T>(x: T): Promise<T>;
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>T : Symbol(T, Decl(awaited.ts, 12, 29))
+>x : Symbol(x, Decl(awaited.ts, 12, 32))
+>T : Symbol(T, Decl(awaited.ts, 12, 29))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>T : Symbol(T, Decl(awaited.ts, 12, 29))
+
+makePromise(1).then(x => x);
+>makePromise(1).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 13, 20))
+>x : Symbol(x, Decl(awaited.ts, 13, 20))
+
+makePromise("a").then(x => x);
+>makePromise("a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 14, 22))
+>x : Symbol(x, Decl(awaited.ts, 14, 22))
+
+makePromise({ a: 1 }).then(x => x);
+>makePromise({ a: 1 }).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>a : Symbol(a, Decl(awaited.ts, 15, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 15, 27))
+>x : Symbol(x, Decl(awaited.ts, 15, 27))
+
+makePromise(f ? 1 : "a").then(x => x);
+>makePromise(f ? 1 : "a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 16, 30))
+>x : Symbol(x, Decl(awaited.ts, 16, 30))
+
+function f0<U>(u: U) {
+>f0 : Symbol(f0, Decl(awaited.ts, 16, 38))
+>U : Symbol(U, Decl(awaited.ts, 18, 12))
+>u : Symbol(u, Decl(awaited.ts, 18, 15))
+>U : Symbol(U, Decl(awaited.ts, 18, 12))
+
+    return makePromise(u).then(x => x);
+>makePromise(u).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>u : Symbol(u, Decl(awaited.ts, 18, 15))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 19, 31))
+>x : Symbol(x, Decl(awaited.ts, 19, 31))
+}
+f0(1).then(x => x);
+>f0(1).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f0 : Symbol(f0, Decl(awaited.ts, 16, 38))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 21, 11))
+>x : Symbol(x, Decl(awaited.ts, 21, 11))
+
+f0("a").then(x => x);
+>f0("a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f0 : Symbol(f0, Decl(awaited.ts, 16, 38))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 22, 13))
+>x : Symbol(x, Decl(awaited.ts, 22, 13))
+
+f0(f ? 1 : "a").then(x => x);
+>f0(f ? 1 : "a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f0 : Symbol(f0, Decl(awaited.ts, 16, 38))
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 23, 21))
+>x : Symbol(x, Decl(awaited.ts, 23, 21))
+
+f0(makePromise(1)).then(x => x);
+>f0(makePromise(1)).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f0 : Symbol(f0, Decl(awaited.ts, 16, 38))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 24, 24))
+>x : Symbol(x, Decl(awaited.ts, 24, 24))
+
+function f1<U, V>(u: U, v: V) {
+>f1 : Symbol(f1, Decl(awaited.ts, 24, 32))
+>U : Symbol(U, Decl(awaited.ts, 26, 12))
+>V : Symbol(V, Decl(awaited.ts, 26, 14))
+>u : Symbol(u, Decl(awaited.ts, 26, 18))
+>U : Symbol(U, Decl(awaited.ts, 26, 12))
+>v : Symbol(v, Decl(awaited.ts, 26, 23))
+>V : Symbol(V, Decl(awaited.ts, 26, 14))
+
+    return makePromise(u).then(x => {
+>makePromise(u).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>u : Symbol(u, Decl(awaited.ts, 26, 18))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 27, 31))
+
+        if (f) return x;
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+>x : Symbol(x, Decl(awaited.ts, 27, 31))
+
+        return makePromise(v).then(x => x);
+>makePromise(v).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>v : Symbol(v, Decl(awaited.ts, 26, 23))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 29, 35))
+>x : Symbol(x, Decl(awaited.ts, 29, 35))
+
+    });
+}
+f1(1, "a").then(x => x);
+>f1(1, "a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f1 : Symbol(f1, Decl(awaited.ts, 24, 32))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 32, 16))
+>x : Symbol(x, Decl(awaited.ts, 32, 16))
+
+f1(makePromise(1), makePromise("a")).then(x => x);
+>f1(makePromise(1), makePromise("a")).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f1 : Symbol(f1, Decl(awaited.ts, 24, 32))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 33, 42))
+>x : Symbol(x, Decl(awaited.ts, 33, 42))
+
+function f2<U>(u: U) {
+>f2 : Symbol(f2, Decl(awaited.ts, 33, 50))
+>U : Symbol(U, Decl(awaited.ts, 35, 12))
+>u : Symbol(u, Decl(awaited.ts, 35, 15))
+>U : Symbol(U, Decl(awaited.ts, 35, 12))
+
+    return makePromise(u).then(x => {
+>makePromise(u).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>u : Symbol(u, Decl(awaited.ts, 35, 15))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 36, 31))
+
+        if (f) return x;
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+>x : Symbol(x, Decl(awaited.ts, 36, 31))
+
+        return Promise.reject("b");
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+    });
+}
+f2(1).then(x => x);
+>f2(1).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f2 : Symbol(f2, Decl(awaited.ts, 33, 50))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 41, 11))
+>x : Symbol(x, Decl(awaited.ts, 41, 11))
+
+f2(makePromise(1)).then(x => x);
+>f2(makePromise(1)).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f2 : Symbol(f2, Decl(awaited.ts, 33, 50))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 42, 24))
+>x : Symbol(x, Decl(awaited.ts, 42, 24))
+
+function f3<U, V>(u: U, v: V) {
+>f3 : Symbol(f3, Decl(awaited.ts, 42, 32))
+>U : Symbol(U, Decl(awaited.ts, 44, 12))
+>V : Symbol(V, Decl(awaited.ts, 44, 14))
+>u : Symbol(u, Decl(awaited.ts, 44, 18))
+>U : Symbol(U, Decl(awaited.ts, 44, 12))
+>v : Symbol(v, Decl(awaited.ts, 44, 23))
+>V : Symbol(V, Decl(awaited.ts, 44, 14))
+
+    return makePromise(u).catch(x => v);
+>makePromise(u).catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>u : Symbol(u, Decl(awaited.ts, 44, 18))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 45, 32))
+>v : Symbol(v, Decl(awaited.ts, 44, 23))
+}
+f3(1, "a").then(x => x);
+>f3(1, "a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f3 : Symbol(f3, Decl(awaited.ts, 42, 32))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 47, 16))
+>x : Symbol(x, Decl(awaited.ts, 47, 16))
+
+f3(makePromise(1), makePromise("a")).then(x => x);
+>f3(makePromise(1), makePromise("a")).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f3 : Symbol(f3, Decl(awaited.ts, 42, 32))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 48, 42))
+>x : Symbol(x, Decl(awaited.ts, 48, 42))
+
+function f4<U, V>(u: U, v: V) {
+>f4 : Symbol(f4, Decl(awaited.ts, 48, 50))
+>U : Symbol(U, Decl(awaited.ts, 50, 12))
+>V : Symbol(V, Decl(awaited.ts, 50, 14))
+>u : Symbol(u, Decl(awaited.ts, 50, 18))
+>U : Symbol(U, Decl(awaited.ts, 50, 12))
+>v : Symbol(v, Decl(awaited.ts, 50, 23))
+>V : Symbol(V, Decl(awaited.ts, 50, 14))
+
+    return makePromise(u).catch(x => {
+>makePromise(u).catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>u : Symbol(u, Decl(awaited.ts, 50, 18))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 51, 32))
+
+        if (f) return v;
+>f : Symbol(f, Decl(awaited.ts, 11, 13))
+>v : Symbol(v, Decl(awaited.ts, 50, 23))
+
+        return Promise.reject("b");
+>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+    });
+}
+f4(1, "a").then(x => x);
+>f4(1, "a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f4 : Symbol(f4, Decl(awaited.ts, 48, 50))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 56, 16))
+>x : Symbol(x, Decl(awaited.ts, 56, 16))
+
+f4(makePromise(1), makePromise("a")).then(x => x);
+>f4(makePromise(1), makePromise("a")).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f4 : Symbol(f4, Decl(awaited.ts, 48, 50))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 57, 42))
+>x : Symbol(x, Decl(awaited.ts, 57, 42))
+
+async function f5<U>(u: Promise<U>) {
+>f5 : Symbol(f5, Decl(awaited.ts, 57, 50))
+>U : Symbol(U, Decl(awaited.ts, 59, 18))
+>u : Symbol(u, Decl(awaited.ts, 59, 21))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>U : Symbol(U, Decl(awaited.ts, 59, 18))
+
+    return await u;
+>u : Symbol(u, Decl(awaited.ts, 59, 21))
+}
+f5(makePromise(1)).then(x => x);
+>f5(makePromise(1)).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f5 : Symbol(f5, Decl(awaited.ts, 57, 50))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 62, 24))
+>x : Symbol(x, Decl(awaited.ts, 62, 24))
+
+f5(makePromise(makePromise(1))).then(x => x);
+>f5(makePromise(makePromise(1))).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>f5 : Symbol(f5, Decl(awaited.ts, 57, 50))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>makePromise : Symbol(makePromise, Decl(awaited.ts, 11, 25))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(awaited.ts, 63, 37))
+>x : Symbol(x, Decl(awaited.ts, 63, 37))
+
+async function f6<U>(u: Promise<Promise<U>>) {
+>f6 : Symbol(f6, Decl(awaited.ts, 63, 45))
+>U : Symbol(U, Decl(awaited.ts, 65, 18))
+>u : Symbol(u, Decl(awaited.ts, 65, 21))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>U : Symbol(U, Decl(awaited.ts, 65, 18))
+
+    return await u;
+>u : Symbol(u, Decl(awaited.ts, 65, 21))
+}
+
+// assignability
+let v0: number;
+>v0 : Symbol(v0, Decl(awaited.ts, 70, 3))
+
+let v1: awaited number;
+>v1 : Symbol(v1, Decl(awaited.ts, 71, 3))
+
+let v2: awaited Promise<number>;
+>v2 : Symbol(v2, Decl(awaited.ts, 72, 3))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+v0 = v1;
+>v0 : Symbol(v0, Decl(awaited.ts, 70, 3))
+>v1 : Symbol(v1, Decl(awaited.ts, 71, 3))
+
+v0 = v2;
+>v0 : Symbol(v0, Decl(awaited.ts, 70, 3))
+>v2 : Symbol(v2, Decl(awaited.ts, 72, 3))
+
+v1 = v0;
+>v1 : Symbol(v1, Decl(awaited.ts, 71, 3))
+>v0 : Symbol(v0, Decl(awaited.ts, 70, 3))
+
+v1 = v2;
+>v1 : Symbol(v1, Decl(awaited.ts, 71, 3))
+>v2 : Symbol(v2, Decl(awaited.ts, 72, 3))
+
+v2 = v0;
+>v2 : Symbol(v2, Decl(awaited.ts, 72, 3))
+>v0 : Symbol(v0, Decl(awaited.ts, 70, 3))
+
+v2 = v1;
+>v2 : Symbol(v2, Decl(awaited.ts, 72, 3))
+>v1 : Symbol(v1, Decl(awaited.ts, 71, 3))
+
+function f7<U>() {
+>f7 : Symbol(f7, Decl(awaited.ts, 78, 8))
+>U : Symbol(U, Decl(awaited.ts, 80, 12))
+
+    let v0: awaited U;
+>v0 : Symbol(v0, Decl(awaited.ts, 81, 7))
+>U : Symbol(U, Decl(awaited.ts, 80, 12))
+
+    let v1: awaited Promise<U>;
+>v1 : Symbol(v1, Decl(awaited.ts, 82, 7))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>U : Symbol(U, Decl(awaited.ts, 80, 12))
+
+    v0 = v1;
+>v0 : Symbol(v0, Decl(awaited.ts, 81, 7))
+>v1 : Symbol(v1, Decl(awaited.ts, 82, 7))
+
+    v1 = v0;
+>v1 : Symbol(v1, Decl(awaited.ts, 82, 7))
+>v0 : Symbol(v0, Decl(awaited.ts, 81, 7))
+}
+
+async function f8<U>() {
+>f8 : Symbol(f8, Decl(awaited.ts, 85, 1))
+>U : Symbol(U, Decl(awaited.ts, 87, 18))
+
+    let pu: Promise<U>;
+>pu : Symbol(pu, Decl(awaited.ts, 88, 7))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>U : Symbol(U, Decl(awaited.ts, 87, 18))
+
+    let v0: awaited U;
+>v0 : Symbol(v0, Decl(awaited.ts, 89, 7))
+>U : Symbol(U, Decl(awaited.ts, 87, 18))
+
+    let v1: awaited Promise<U>;
+>v1 : Symbol(v1, Decl(awaited.ts, 90, 7))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>U : Symbol(U, Decl(awaited.ts, 87, 18))
+
+    v0 = await pu;
+>v0 : Symbol(v0, Decl(awaited.ts, 89, 7))
+>pu : Symbol(pu, Decl(awaited.ts, 88, 7))
+
+    v1 = await pu;
+>v1 : Symbol(v1, Decl(awaited.ts, 90, 7))
+>pu : Symbol(pu, Decl(awaited.ts, 88, 7))
+}
diff --git a/tests/baselines/reference/promised.types b/tests/baselines/reference/awaited.types
similarity index 68%
rename from tests/baselines/reference/promised.types
rename to tests/baselines/reference/awaited.types
index 54e0aea977a..0e2a30f89fd 100644
--- a/tests/baselines/reference/promised.types
+++ b/tests/baselines/reference/awaited.types
@@ -1,4 +1,4 @@
-=== tests/cases/conformance/types/promised/promised.ts ===
+=== tests/cases/conformance/types/awaited/awaited.ts ===
 // simple
 declare const p0: Promise<number>;
 >p0 : Promise<number>
@@ -6,9 +6,9 @@ declare const p0: Promise<number>;
 
 p0.then(x => x);
 >p0.then(x => x) : Promise<number>
->p0.then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p0.then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p0 : Promise<number>
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: number) => number
 >x : number
 >x : number
@@ -20,9 +20,9 @@ declare const p1: Promise<Promise<number>>;
 
 p1.then(x => x);
 >p1.then(x => x) : Promise<number>
->p1.then : <TResult1 = Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<Promise<number>>
->then : <TResult1 = Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: number) => number
 >x : number
 >x : number
@@ -34,9 +34,9 @@ declare const p2: Promise<number | Promise<number>>;
 
 p2.then(x => x);
 >p2.then(x => x) : Promise<number>
->p2.then : <TResult1 = number | Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p2.then : <TResult1 = number | Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p2 : Promise<number | Promise<number>>
->then : <TResult1 = number | Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = number | Promise<number>, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: number) => number
 >x : number
 >x : number
@@ -55,121 +55,121 @@ declare function makePromise<T>(x: T): Promise<T>;
 
 makePromise(1).then(x => x);
 >makePromise(1).then(x => x) : Promise<number>
->makePromise(1).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>makePromise(1).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >makePromise(1) : Promise<number>
 >makePromise : <T>(x: T) => Promise<T>
 >1 : 1
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: number) => number
 >x : number
 >x : number
 
 makePromise("a").then(x => x);
 >makePromise("a").then(x => x) : Promise<string>
->makePromise("a").then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>makePromise("a").then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >makePromise("a") : Promise<string>
 >makePromise : <T>(x: T) => Promise<T>
 >"a" : "a"
->then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: string) => string
 >x : string
 >x : string
 
 makePromise({ a: 1 }).then(x => x);
 >makePromise({ a: 1 }).then(x => x) : Promise<{ a: number; }>
->makePromise({ a: 1 }).then : <TResult1 = { a: number; }, TResult2 = never>(onfulfilled?: (value: { a: number; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>makePromise({ a: 1 }).then : <TResult1 = { a: number; }, TResult2 = never>(onfulfilled?: (value: { a: number; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >makePromise({ a: 1 }) : Promise<{ a: number; }>
 >makePromise : <T>(x: T) => Promise<T>
 >{ a: 1 } : { a: number; }
 >a : number
 >1 : 1
->then : <TResult1 = { a: number; }, TResult2 = never>(onfulfilled?: (value: { a: number; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = { a: number; }, TResult2 = never>(onfulfilled?: (value: { a: number; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: { a: number; }) => { a: number; }
 >x : { a: number; }
 >x : { a: number; }
 
 makePromise(f ? 1 : "a").then(x => x);
 >makePromise(f ? 1 : "a").then(x => x) : Promise<string | number>
->makePromise(f ? 1 : "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>makePromise(f ? 1 : "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >makePromise(f ? 1 : "a") : Promise<string | number>
 >makePromise : <T>(x: T) => Promise<T>
 >f ? 1 : "a" : 1 | "a"
 >f : boolean
 >1 : 1
 >"a" : "a"
->then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: string | number) => string | number
 >x : string | number
 >x : string | number
 
 function f0<U>(u: U) {
->f0 : <U>(u: U) => Promise<promised U>
+>f0 : <U>(u: U) => Promise<awaited U>
 >U : U
 >u : U
 >U : U
 
     return makePromise(u).then(x => x);
->makePromise(u).then(x => x) : Promise<promised U>
->makePromise(u).then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: promised U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>makePromise(u).then(x => x) : Promise<awaited U>
+>makePromise(u).then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >makePromise(u) : Promise<U>
 >makePromise : <T>(x: T) => Promise<T>
 >u : U
->then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: promised U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
->x => x : (x: promised U) => promised U
->x : promised U
->x : promised U
+>then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: awaited U) => awaited U
+>x : awaited U
+>x : awaited U
 }
 f0(1).then(x => x);
 >f0(1).then(x => x) : Promise<number>
->f0(1).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f0(1).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f0(1) : Promise<number>
->f0 : <U>(u: U) => Promise<promised U>
+>f0 : <U>(u: U) => Promise<awaited U>
 >1 : 1
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: number) => number
 >x : number
 >x : number
 
 f0("a").then(x => x);
 >f0("a").then(x => x) : Promise<string>
->f0("a").then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f0("a").then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f0("a") : Promise<string>
->f0 : <U>(u: U) => Promise<promised U>
+>f0 : <U>(u: U) => Promise<awaited U>
 >"a" : "a"
->then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: string) => string
 >x : string
 >x : string
 
 f0(f ? 1 : "a").then(x => x);
 >f0(f ? 1 : "a").then(x => x) : Promise<string | number>
->f0(f ? 1 : "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f0(f ? 1 : "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f0(f ? 1 : "a") : Promise<string | number>
->f0 : <U>(u: U) => Promise<promised U>
+>f0 : <U>(u: U) => Promise<awaited U>
 >f ? 1 : "a" : 1 | "a"
 >f : boolean
 >1 : 1
 >"a" : "a"
->then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: string | number) => string | number
 >x : string | number
 >x : string | number
 
 f0(makePromise(1)).then(x => x);
 >f0(makePromise(1)).then(x => x) : Promise<number>
->f0(makePromise(1)).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f0(makePromise(1)).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f0(makePromise(1)) : Promise<number>
->f0 : <U>(u: U) => Promise<promised U>
+>f0 : <U>(u: U) => Promise<awaited U>
 >makePromise(1) : Promise<number>
 >makePromise : <T>(x: T) => Promise<T>
 >1 : 1
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: number) => number
 >x : number
 >x : number
 
 function f1<U, V>(u: U, v: V) {
->f1 : <U, V>(u: U, v: V) => Promise<promised U | promised V>
+>f1 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
 >U : U
 >V : V
 >u : U
@@ -178,115 +178,115 @@ function f1<U, V>(u: U, v: V) {
 >V : V
 
     return makePromise(u).then(x => {
->makePromise(u).then(x => {        if (f) return x;        return makePromise(v).then(x => x);    }) : Promise<promised U | promised V>
->makePromise(u).then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: promised U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>makePromise(u).then(x => {        if (f) return x;        return makePromise(v).then(x => x);    }) : Promise<awaited U | awaited V>
+>makePromise(u).then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >makePromise(u) : Promise<U>
 >makePromise : <T>(x: T) => Promise<T>
 >u : U
->then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: promised U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
->x => {        if (f) return x;        return makePromise(v).then(x => x);    } : (x: promised U) => promised U | Promise<promised V>
->x : promised U
+>then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => {        if (f) return x;        return makePromise(v).then(x => x);    } : (x: awaited U) => awaited U | Promise<awaited V>
+>x : awaited U
 
         if (f) return x;
 >f : boolean
->x : promised U
+>x : awaited U
 
         return makePromise(v).then(x => x);
->makePromise(v).then(x => x) : Promise<promised V>
->makePromise(v).then : <TResult1 = V, TResult2 = never>(onfulfilled?: (value: promised V) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>makePromise(v).then(x => x) : Promise<awaited V>
+>makePromise(v).then : <TResult1 = V, TResult2 = never>(onfulfilled?: (value: awaited V) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >makePromise(v) : Promise<V>
 >makePromise : <T>(x: T) => Promise<T>
 >v : V
->then : <TResult1 = V, TResult2 = never>(onfulfilled?: (value: promised V) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
->x => x : (x: promised V) => promised V
->x : promised V
->x : promised V
+>then : <TResult1 = V, TResult2 = never>(onfulfilled?: (value: awaited V) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => x : (x: awaited V) => awaited V
+>x : awaited V
+>x : awaited V
 
     });
 }
 f1(1, "a").then(x => x);
 >f1(1, "a").then(x => x) : Promise<string | number>
->f1(1, "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f1(1, "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f1(1, "a") : Promise<string | number>
->f1 : <U, V>(u: U, v: V) => Promise<promised U | promised V>
+>f1 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
 >1 : 1
 >"a" : "a"
->then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: string | number) => string | number
 >x : string | number
 >x : string | number
 
 f1(makePromise(1), makePromise("a")).then(x => x);
 >f1(makePromise(1), makePromise("a")).then(x => x) : Promise<string | number>
->f1(makePromise(1), makePromise("a")).then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f1(makePromise(1), makePromise("a")).then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f1(makePromise(1), makePromise("a")) : Promise<string | number>
->f1 : <U, V>(u: U, v: V) => Promise<promised U | promised V>
+>f1 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
 >makePromise(1) : Promise<number>
 >makePromise : <T>(x: T) => Promise<T>
 >1 : 1
 >makePromise("a") : Promise<string>
 >makePromise : <T>(x: T) => Promise<T>
 >"a" : "a"
->then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: string | number) => string | number
 >x : string | number
 >x : string | number
 
 function f2<U>(u: U) {
->f2 : <U>(u: U) => Promise<promised U>
+>f2 : <U>(u: U) => Promise<awaited U>
 >U : U
 >u : U
 >U : U
 
     return makePromise(u).then(x => {
->makePromise(u).then(x => {        if (f) return x;        return Promise.reject("b");    }) : Promise<promised U>
->makePromise(u).then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: promised U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>makePromise(u).then(x => {        if (f) return x;        return Promise.reject("b");    }) : Promise<awaited U>
+>makePromise(u).then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >makePromise(u) : Promise<U>
 >makePromise : <T>(x: T) => Promise<T>
 >u : U
->then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: promised U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
->x => {        if (f) return x;        return Promise.reject("b");    } : (x: promised U) => promised U | Promise<never>
->x : promised U
+>then : <TResult1 = U, TResult2 = never>(onfulfilled?: (value: awaited U) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
+>x => {        if (f) return x;        return Promise.reject("b");    } : (x: awaited U) => awaited U | Promise<never>
+>x : awaited U
 
         if (f) return x;
 >f : boolean
->x : promised U
+>x : awaited U
 
         return Promise.reject("b");
 >Promise.reject("b") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"b" : "b"
 
     });
 }
 f2(1).then(x => x);
 >f2(1).then(x => x) : Promise<number>
->f2(1).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f2(1).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f2(1) : Promise<number>
->f2 : <U>(u: U) => Promise<promised U>
+>f2 : <U>(u: U) => Promise<awaited U>
 >1 : 1
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: number) => number
 >x : number
 >x : number
 
 f2(makePromise(1)).then(x => x);
 >f2(makePromise(1)).then(x => x) : Promise<number>
->f2(makePromise(1)).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f2(makePromise(1)).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f2(makePromise(1)) : Promise<number>
->f2 : <U>(u: U) => Promise<promised U>
+>f2 : <U>(u: U) => Promise<awaited U>
 >makePromise(1) : Promise<number>
 >makePromise : <T>(x: T) => Promise<T>
 >1 : 1
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: number) => number
 >x : number
 >x : number
 
 function f3<U, V>(u: U, v: V) {
->f3 : <U, V>(u: U, v: V) => Promise<promised U | promised V>
+>f3 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
 >U : U
 >V : V
 >u : U
@@ -295,46 +295,46 @@ function f3<U, V>(u: U, v: V) {
 >V : V
 
     return makePromise(u).catch(x => v);
->makePromise(u).catch(x => v) : Promise<promised U | promised V>
->makePromise(u).catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<promised U | promised TResult>
+>makePromise(u).catch(x => v) : Promise<awaited U | awaited V>
+>makePromise(u).catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<awaited U | awaited TResult>
 >makePromise(u) : Promise<U>
 >makePromise : <T>(x: T) => Promise<T>
 >u : U
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<promised U | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<awaited U | awaited TResult>
 >x => v : (x: any) => V
 >x : any
 >v : V
 }
 f3(1, "a").then(x => x);
 >f3(1, "a").then(x => x) : Promise<string | number>
->f3(1, "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f3(1, "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f3(1, "a") : Promise<string | number>
->f3 : <U, V>(u: U, v: V) => Promise<promised U | promised V>
+>f3 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
 >1 : 1
 >"a" : "a"
->then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: string | number) => string | number
 >x : string | number
 >x : string | number
 
 f3(makePromise(1), makePromise("a")).then(x => x);
 >f3(makePromise(1), makePromise("a")).then(x => x) : Promise<string | number>
->f3(makePromise(1), makePromise("a")).then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f3(makePromise(1), makePromise("a")).then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f3(makePromise(1), makePromise("a")) : Promise<string | number>
->f3 : <U, V>(u: U, v: V) => Promise<promised U | promised V>
+>f3 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
 >makePromise(1) : Promise<number>
 >makePromise : <T>(x: T) => Promise<T>
 >1 : 1
 >makePromise("a") : Promise<string>
 >makePromise : <T>(x: T) => Promise<T>
 >"a" : "a"
->then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: string | number) => string | number
 >x : string | number
 >x : string | number
 
 function f4<U, V>(u: U, v: V) {
->f4 : <U, V>(u: U, v: V) => Promise<promised U | promised V>
+>f4 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
 >U : U
 >V : V
 >u : U
@@ -343,12 +343,12 @@ function f4<U, V>(u: U, v: V) {
 >V : V
 
     return makePromise(u).catch(x => {
->makePromise(u).catch(x => {        if (f) return v;        return Promise.reject("b");    }) : Promise<promised U | promised V>
->makePromise(u).catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<promised U | promised TResult>
+>makePromise(u).catch(x => {        if (f) return v;        return Promise.reject("b");    }) : Promise<awaited U | awaited V>
+>makePromise(u).catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<awaited U | awaited TResult>
 >makePromise(u) : Promise<U>
 >makePromise : <T>(x: T) => Promise<T>
 >u : U
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<promised U | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<awaited U | awaited TResult>
 >x => {        if (f) return v;        return Promise.reject("b");    } : (x: any) => Promise<never> | V
 >x : any
 
@@ -358,82 +358,82 @@ function f4<U, V>(u: U, v: V) {
 
         return Promise.reject("b");
 >Promise.reject("b") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"b" : "b"
 
     });
 }
 f4(1, "a").then(x => x);
 >f4(1, "a").then(x => x) : Promise<string | number>
->f4(1, "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f4(1, "a").then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f4(1, "a") : Promise<string | number>
->f4 : <U, V>(u: U, v: V) => Promise<promised U | promised V>
+>f4 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
 >1 : 1
 >"a" : "a"
->then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: string | number) => string | number
 >x : string | number
 >x : string | number
 
 f4(makePromise(1), makePromise("a")).then(x => x);
 >f4(makePromise(1), makePromise("a")).then(x => x) : Promise<string | number>
->f4(makePromise(1), makePromise("a")).then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f4(makePromise(1), makePromise("a")).then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f4(makePromise(1), makePromise("a")) : Promise<string | number>
->f4 : <U, V>(u: U, v: V) => Promise<promised U | promised V>
+>f4 : <U, V>(u: U, v: V) => Promise<awaited U | awaited V>
 >makePromise(1) : Promise<number>
 >makePromise : <T>(x: T) => Promise<T>
 >1 : 1
 >makePromise("a") : Promise<string>
 >makePromise : <T>(x: T) => Promise<T>
 >"a" : "a"
->then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = string | number, TResult2 = never>(onfulfilled?: (value: string | number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: string | number) => string | number
 >x : string | number
 >x : string | number
 
 async function f5<U>(u: Promise<U>) {
->f5 : <U>(u: Promise<U>) => Promise<promised U>
+>f5 : <U>(u: Promise<U>) => Promise<awaited U>
 >U : U
 >u : Promise<U>
 >Promise : Promise<T>
 >U : U
 
     return await u;
->await u : promised U
+>await u : awaited U
 >u : Promise<U>
 }
 f5(makePromise(1)).then(x => x);
 >f5(makePromise(1)).then(x => x) : Promise<number>
->f5(makePromise(1)).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f5(makePromise(1)).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f5(makePromise(1)) : Promise<number>
->f5 : <U>(u: Promise<U>) => Promise<promised U>
+>f5 : <U>(u: Promise<U>) => Promise<awaited U>
 >makePromise(1) : Promise<number>
 >makePromise : <T>(x: T) => Promise<T>
 >1 : 1
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: number) => number
 >x : number
 >x : number
 
 f5(makePromise(makePromise(1))).then(x => x);
 >f5(makePromise(makePromise(1))).then(x => x) : Promise<number>
->f5(makePromise(makePromise(1))).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f5(makePromise(makePromise(1))).then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f5(makePromise(makePromise(1))) : Promise<number>
->f5 : <U>(u: Promise<U>) => Promise<promised U>
+>f5 : <U>(u: Promise<U>) => Promise<awaited U>
 >makePromise(makePromise(1)) : Promise<Promise<number>>
 >makePromise : <T>(x: T) => Promise<T>
 >makePromise(1) : Promise<number>
 >makePromise : <T>(x: T) => Promise<T>
 >1 : 1
->then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x => x : (x: number) => number
 >x : number
 >x : number
 
 async function f6<U>(u: Promise<Promise<U>>) {
->f6 : <U>(u: Promise<Promise<U>>) => Promise<promised U>
+>f6 : <U>(u: Promise<Promise<U>>) => Promise<awaited U>
 >U : U
 >u : Promise<Promise<U>>
 >Promise : Promise<T>
@@ -441,7 +441,7 @@ async function f6<U>(u: Promise<Promise<U>>) {
 >U : U
 
     return await u;
->await u : promised U
+>await u : awaited U
 >u : Promise<Promise<U>>
 }
 
@@ -449,10 +449,10 @@ async function f6<U>(u: Promise<Promise<U>>) {
 let v0: number;
 >v0 : number
 
-let v1: promised number;
+let v1: awaited number;
 >v1 : number
 
-let v2: promised Promise<number>;
+let v2: awaited Promise<number>;
 >v2 : number
 >Promise : Promise<T>
 
@@ -490,24 +490,24 @@ function f7<U>() {
 >f7 : <U>() => void
 >U : U
 
-    let v0: promised U;
->v0 : promised U
+    let v0: awaited U;
+>v0 : awaited U
 >U : U
 
-    let v1: promised Promise<U>;
->v1 : promised U
+    let v1: awaited Promise<U>;
+>v1 : awaited U
 >Promise : Promise<T>
 >U : U
 
     v0 = v1;
->v0 = v1 : promised U
->v0 : promised U
->v1 : promised U
+>v0 = v1 : awaited U
+>v0 : awaited U
+>v1 : awaited U
 
     v1 = v0;
->v1 = v0 : promised U
->v1 : promised U
->v0 : promised U
+>v1 = v0 : awaited U
+>v1 : awaited U
+>v0 : awaited U
 }
 
 async function f8<U>() {
@@ -519,24 +519,24 @@ async function f8<U>() {
 >Promise : Promise<T>
 >U : U
 
-    let v0: promised U;
->v0 : promised U
+    let v0: awaited U;
+>v0 : awaited U
 >U : U
 
-    let v1: promised Promise<U>;
->v1 : promised U
+    let v1: awaited Promise<U>;
+>v1 : awaited U
 >Promise : Promise<T>
 >U : U
 
     v0 = await pu;
->v0 = await pu : promised U
->v0 : promised U
->await pu : promised U
+>v0 = await pu : awaited U
+>v0 : awaited U
+>await pu : awaited U
 >pu : Promise<U>
 
     v1 = await pu;
->v1 = await pu : promised U
->v1 : promised U
->await pu : promised U
+>v1 = await pu : awaited U
+>v1 : awaited U
+>await pu : awaited U
 >pu : Promise<U>
 }
diff --git a/tests/baselines/reference/correctOrderOfPromiseMethod.types b/tests/baselines/reference/correctOrderOfPromiseMethod.types
index cd7c228430b..a7ee9d1e73f 100644
--- a/tests/baselines/reference/correctOrderOfPromiseMethod.types
+++ b/tests/baselines/reference/correctOrderOfPromiseMethod.types
@@ -39,9 +39,9 @@ async function countEverything(): Promise<number> {
 >resultB : B[]
 >await Promise.all([        providerA(),        providerB(),    ]) : [A[], B[]]
 >Promise.all([        providerA(),        providerB(),    ]) : Promise<[A[], B[]]>
->Promise.all : { <TAll>(values: Iterable<TAll>): Promise<(promised TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8, promised T9, promised T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8, promised T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[promised T1, promised T2, promised T3, promised T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[promised T1, promised T2, promised T3]>; <T1, T2>(values: [T1, T2]): Promise<[promised T1, promised T2]>; <T>(values: T[]): Promise<(promised T)[]>; }
+>Promise.all : { <TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9, awaited T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: T[]): Promise<(awaited T)[]>; }
 >Promise : PromiseConstructor
->all : { <TAll>(values: Iterable<TAll>): Promise<(promised TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8, promised T9, promised T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8, promised T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[promised T1, promised T2, promised T3, promised T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[promised T1, promised T2, promised T3]>; <T1, T2>(values: [T1, T2]): Promise<[promised T1, promised T2]>; <T>(values: T[]): Promise<(promised T)[]>; }
+>all : { <TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9, awaited T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: T[]): Promise<(awaited T)[]>; }
 >[        providerA(),        providerB(),    ] : [Promise<A[]>, Promise<B[]>]
 
         providerA(),
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.types b/tests/baselines/reference/exportDefaultAsyncFunction2.types
index 69aba8c8bfb..601ebb45a95 100644
--- a/tests/baselines/reference/exportDefaultAsyncFunction2.types
+++ b/tests/baselines/reference/exportDefaultAsyncFunction2.types
@@ -20,9 +20,9 @@ export default async(() => await(Promise.resolve(1)));
 >await(Promise.resolve(1)) : any
 >await : (...args: any[]) => any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 === tests/cases/compiler/b.ts ===
diff --git a/tests/baselines/reference/importCallExpression1ESNext.types b/tests/baselines/reference/importCallExpression1ESNext.types
index 89486ce75cc..ab3aed8dc7a 100644
--- a/tests/baselines/reference/importCallExpression1ESNext.types
+++ b/tests/baselines/reference/importCallExpression1ESNext.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpression2ESNext.types b/tests/baselines/reference/importCallExpression2ESNext.types
index a0745378a4c..ae71327fd7a 100644
--- a/tests/baselines/reference/importCallExpression2ESNext.types
+++ b/tests/baselines/reference/importCallExpression2ESNext.types
@@ -15,9 +15,9 @@ function foo(x: Promise<any>) {
 
     x.then(value => {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
->x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >value : any
 
diff --git a/tests/baselines/reference/importCallExpression4ESNext.types b/tests/baselines/reference/importCallExpression4ESNext.types
index c316c881816..17735c793cd 100644
--- a/tests/baselines/reference/importCallExpression4ESNext.types
+++ b/tests/baselines/reference/importCallExpression4ESNext.types
@@ -38,11 +38,11 @@ class C {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES5AMD.types b/tests/baselines/reference/importCallExpressionES5AMD.types
index 4232cb2495b..82fd2046775 100644
--- a/tests/baselines/reference/importCallExpressionES5AMD.types
+++ b/tests/baselines/reference/importCallExpressionES5AMD.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES5CJS.types b/tests/baselines/reference/importCallExpressionES5CJS.types
index 4232cb2495b..82fd2046775 100644
--- a/tests/baselines/reference/importCallExpressionES5CJS.types
+++ b/tests/baselines/reference/importCallExpressionES5CJS.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES5System.types b/tests/baselines/reference/importCallExpressionES5System.types
index 7d3aaa1f798..e38046f93aa 100644
--- a/tests/baselines/reference/importCallExpressionES5System.types
+++ b/tests/baselines/reference/importCallExpressionES5System.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }
 
diff --git a/tests/baselines/reference/importCallExpressionES5UMD.types b/tests/baselines/reference/importCallExpressionES5UMD.types
index 4232cb2495b..82fd2046775 100644
--- a/tests/baselines/reference/importCallExpressionES5UMD.types
+++ b/tests/baselines/reference/importCallExpressionES5UMD.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES6AMD.types b/tests/baselines/reference/importCallExpressionES6AMD.types
index 4232cb2495b..82fd2046775 100644
--- a/tests/baselines/reference/importCallExpressionES6AMD.types
+++ b/tests/baselines/reference/importCallExpressionES6AMD.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES6CJS.types b/tests/baselines/reference/importCallExpressionES6CJS.types
index 4232cb2495b..82fd2046775 100644
--- a/tests/baselines/reference/importCallExpressionES6CJS.types
+++ b/tests/baselines/reference/importCallExpressionES6CJS.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionES6System.types b/tests/baselines/reference/importCallExpressionES6System.types
index 7d3aaa1f798..e38046f93aa 100644
--- a/tests/baselines/reference/importCallExpressionES6System.types
+++ b/tests/baselines/reference/importCallExpressionES6System.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }
 
diff --git a/tests/baselines/reference/importCallExpressionES6UMD.types b/tests/baselines/reference/importCallExpressionES6UMD.types
index 4232cb2495b..82fd2046775 100644
--- a/tests/baselines/reference/importCallExpressionES6UMD.types
+++ b/tests/baselines/reference/importCallExpressionES6UMD.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInAMD1.types b/tests/baselines/reference/importCallExpressionInAMD1.types
index 495ae3fd549..826be9a4caa 100644
--- a/tests/baselines/reference/importCallExpressionInAMD1.types
+++ b/tests/baselines/reference/importCallExpressionInAMD1.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInAMD2.types b/tests/baselines/reference/importCallExpressionInAMD2.types
index 318988f36b8..f950485f685 100644
--- a/tests/baselines/reference/importCallExpressionInAMD2.types
+++ b/tests/baselines/reference/importCallExpressionInAMD2.types
@@ -16,9 +16,9 @@ function foo(x: Promise<any>) {
 
     x.then(value => {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
->x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >value : any
 
diff --git a/tests/baselines/reference/importCallExpressionInAMD4.types b/tests/baselines/reference/importCallExpressionInAMD4.types
index 026c7d847da..033fb0c32e3 100644
--- a/tests/baselines/reference/importCallExpressionInAMD4.types
+++ b/tests/baselines/reference/importCallExpressionInAMD4.types
@@ -38,11 +38,11 @@ class C {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
@@ -105,11 +105,11 @@ export class D {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInCJS1.types b/tests/baselines/reference/importCallExpressionInCJS1.types
index 495ae3fd549..826be9a4caa 100644
--- a/tests/baselines/reference/importCallExpressionInCJS1.types
+++ b/tests/baselines/reference/importCallExpressionInCJS1.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInCJS3.types b/tests/baselines/reference/importCallExpressionInCJS3.types
index 318988f36b8..f950485f685 100644
--- a/tests/baselines/reference/importCallExpressionInCJS3.types
+++ b/tests/baselines/reference/importCallExpressionInCJS3.types
@@ -16,9 +16,9 @@ function foo(x: Promise<any>) {
 
     x.then(value => {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
->x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >value : any
 
diff --git a/tests/baselines/reference/importCallExpressionInCJS5.types b/tests/baselines/reference/importCallExpressionInCJS5.types
index fe743b0eb4a..e36556236c2 100644
--- a/tests/baselines/reference/importCallExpressionInCJS5.types
+++ b/tests/baselines/reference/importCallExpressionInCJS5.types
@@ -38,11 +38,11 @@ class C {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
@@ -105,11 +105,11 @@ export class D {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInSystem1.types b/tests/baselines/reference/importCallExpressionInSystem1.types
index 3b428b3a218..6a73cbcacc9 100644
--- a/tests/baselines/reference/importCallExpressionInSystem1.types
+++ b/tests/baselines/reference/importCallExpressionInSystem1.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }
 
diff --git a/tests/baselines/reference/importCallExpressionInSystem2.types b/tests/baselines/reference/importCallExpressionInSystem2.types
index 93a38e5466a..cfbeb5ff5ce 100644
--- a/tests/baselines/reference/importCallExpressionInSystem2.types
+++ b/tests/baselines/reference/importCallExpressionInSystem2.types
@@ -16,9 +16,9 @@ function foo(x: Promise<any>) {
 
     x.then(value => {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
->x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >value : any
 
diff --git a/tests/baselines/reference/importCallExpressionInSystem4.types b/tests/baselines/reference/importCallExpressionInSystem4.types
index 02b86ce5785..db416f42bd7 100644
--- a/tests/baselines/reference/importCallExpressionInSystem4.types
+++ b/tests/baselines/reference/importCallExpressionInSystem4.types
@@ -38,11 +38,11 @@ class C {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }
 
@@ -105,11 +105,11 @@ export class D {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }>
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }, TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }) => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0" & { default: typeof "tests/cases/conformance/dynamicImport/0"; }
 
diff --git a/tests/baselines/reference/importCallExpressionInUMD1.types b/tests/baselines/reference/importCallExpressionInUMD1.types
index 495ae3fd549..826be9a4caa 100644
--- a/tests/baselines/reference/importCallExpressionInUMD1.types
+++ b/tests/baselines/reference/importCallExpressionInUMD1.types
@@ -15,9 +15,9 @@ var p1 = import("./0");
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
->p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
 >zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionInUMD2.types b/tests/baselines/reference/importCallExpressionInUMD2.types
index 318988f36b8..f950485f685 100644
--- a/tests/baselines/reference/importCallExpressionInUMD2.types
+++ b/tests/baselines/reference/importCallExpressionInUMD2.types
@@ -16,9 +16,9 @@ function foo(x: Promise<any>) {
 
     x.then(value => {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
->x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >x : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >value : any
 
diff --git a/tests/baselines/reference/importCallExpressionInUMD4.types b/tests/baselines/reference/importCallExpressionInUMD4.types
index 026c7d847da..033fb0c32e3 100644
--- a/tests/baselines/reference/importCallExpressionInUMD4.types
+++ b/tests/baselines/reference/importCallExpressionInUMD4.types
@@ -38,11 +38,11 @@ class C {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
@@ -105,11 +105,11 @@ export class D {
 
         this.myModule.then(Zero => {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
->this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
 >this : this
 >myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
->then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
 >Zero : typeof "tests/cases/conformance/dynamicImport/0"
 
diff --git a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
index 738fa40ec27..060a24a81b3 100644
--- a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
+++ b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
@@ -69,9 +69,9 @@ const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof
 
 p1.then(zero => {
 >p1.then(zero => {    return zero.foo();  // ok, zero is any}) : Promise<any>
->p1.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p1.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p1 : Promise<any>
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >zero => {    return zero.foo();  // ok, zero is any} : (zero: any) => any
 >zero : any
 
diff --git a/tests/baselines/reference/importCallExpressionShouldNotGetParen.types b/tests/baselines/reference/importCallExpressionShouldNotGetParen.types
index a8b4394c1c9..4cde8976b43 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, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>import(`./locales/${localeName}.js`).then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >import(`./locales/${localeName}.js`) : Promise<any>
 >`./locales/${localeName}.js` : string
 >localeName : "zh-CN"
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >bar => {    let x = bar;} : (bar: any) => void
 >bar : any
 
@@ -21,14 +21,14 @@ import(`./locales/${localeName}.js`).then(bar => {
 
 import("./locales/" + localeName + ".js").then(bar => {
 >import("./locales/" + localeName + ".js").then(bar => {    let x = bar;}) : Promise<void>
->import("./locales/" + localeName + ".js").then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>import("./locales/" + localeName + ".js").then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >import("./locales/" + localeName + ".js") : Promise<any>
 >"./locales/" + localeName + ".js" : string
 >"./locales/" + localeName : string
 >"./locales/" : "./locales/"
 >localeName : "zh-CN"
 >".js" : ".js"
->then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >bar => {    let x = bar;} : (bar: any) => void
 >bar : any
 
diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types
index 62a3b9ceb46..b117371a6ac 100644
--- a/tests/baselines/reference/inferenceLimit.types
+++ b/tests/baselines/reference/inferenceLimit.types
@@ -46,7 +46,7 @@ export class BrokenClass {
 
         this.doStuff(order.id)
 >this.doStuff(order.id)          .then((items) => {            order.items = items;            resolve(order);          }) : Promise<void>
->this.doStuff(order.id)          .then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>this.doStuff(order.id)          .then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >this.doStuff(order.id) : Promise<void>
 >this.doStuff : (id: number) => Promise<void>
 >this : this
@@ -56,7 +56,7 @@ export class BrokenClass {
 >id : any
 
           .then((items) => {
->then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >(items) => {            order.items = items;            resolve(order);          } : (items: void) => void
 >items : void
 
@@ -78,11 +78,11 @@ export class BrokenClass {
 
     return Promise.all(result.map(populateItems))
 >Promise.all(result.map(populateItems))      .then((orders: Array<MyModule.MyModel>) => {        resolve(orders);      }) : Promise<void>
->Promise.all(result.map(populateItems))      .then : <TResult1 = {}[], TResult2 = never>(onfulfilled?: (value: {}[]) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>Promise.all(result.map(populateItems))      .then : <TResult1 = {}[], TResult2 = never>(onfulfilled?: (value: {}[]) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >Promise.all(result.map(populateItems)) : Promise<{}[]>
->Promise.all : { <TAll>(values: Iterable<TAll>): Promise<(promised TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8, promised T9, promised T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8, promised T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[promised T1, promised T2, promised T3, promised T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[promised T1, promised T2, promised T3]>; <T1, T2>(values: [T1, T2]): Promise<[promised T1, promised T2]>; <T>(values: T[]): Promise<(promised T)[]>; }
+>Promise.all : { <TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9, awaited T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: T[]): Promise<(awaited T)[]>; }
 >Promise : PromiseConstructor
->all : { <TAll>(values: Iterable<TAll>): Promise<(promised TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8, promised T9, promised T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8, promised T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7, promised T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6, promised T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5, promised T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[promised T1, promised T2, promised T3, promised T4, promised T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[promised T1, promised T2, promised T3, promised T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[promised T1, promised T2, promised T3]>; <T1, T2>(values: [T1, T2]): Promise<[promised T1, promised T2]>; <T>(values: T[]): Promise<(promised T)[]>; }
+>all : { <TAll>(values: Iterable<TAll>): Promise<(awaited TAll)[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9, awaited T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1, T2, T3, T4, T5, T6, T7, T8, T9]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8, awaited T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1, T2, T3, T4, T5, T6, T7, T8]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7, awaited T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1, T2, T3, T4, T5, T6, T7]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6, awaited T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1, T2, T3, T4, T5, T6]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5, awaited T6]>; <T1, T2, T3, T4, T5>(values: [T1, T2, T3, T4, T5]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4, awaited T5]>; <T1, T2, T3, T4>(values: [T1, T2, T3, T4]): Promise<[awaited T1, awaited T2, awaited T3, awaited T4]>; <T1, T2, T3>(values: [T1, T2, T3]): Promise<[awaited T1, awaited T2, awaited T3]>; <T1, T2>(values: [T1, T2]): Promise<[awaited T1, awaited T2]>; <T>(values: T[]): Promise<(awaited T)[]>; }
 >result.map(populateItems) : Promise<{}>[]
 >result.map : <U>(callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
 >result : MyModule.MyModel[]
@@ -90,7 +90,7 @@ export class BrokenClass {
 >populateItems : (order: any) => Promise<{}>
 
       .then((orders: Array<MyModule.MyModel>) => {
->then : <TResult1 = {}[], TResult2 = never>(onfulfilled?: (value: {}[]) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = {}[], TResult2 = never>(onfulfilled?: (value: {}[]) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >(orders: Array<MyModule.MyModel>) => {        resolve(orders);      } : (orders: MyModule.MyModel[]) => void
 >orders : MyModule.MyModel[]
 >Array : T[]
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
index 6d8fb231abc..5ca7772ed47 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
@@ -147,10 +147,10 @@ declare var console: any;
 
 out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
->out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >out() : Promise<{}>
 >out : () => Promise<{}>
->then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {    console.log("Yea!");} : () => void
 
     console.log("Yea!");
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
index 9c70575cebf..40d3d8db019 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
@@ -147,10 +147,10 @@ declare var console: any;
 
 out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
->out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >out() : Promise<{}>
 >out : () => Promise<{}>
->then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {    console.log("Yea!");} : () => void
 
     console.log("Yea!");
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
index 1474abdf48d..4a75e812f97 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
@@ -147,10 +147,10 @@ declare var console: any;
 
 out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
->out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>out().then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >out() : Promise<{}>
 >out : () => Promise<{}>
->then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = {}, TResult2 = never>(onfulfilled?: (value: {}) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {    console.log("Yea!");} : () => void
 
     console.log("Yea!");
diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.types b/tests/baselines/reference/noImplicitReturnsInAsync1.types
index 96f5c8071f6..60574005493 100644
--- a/tests/baselines/reference/noImplicitReturnsInAsync1.types
+++ b/tests/baselines/reference/noImplicitReturnsInAsync1.types
@@ -15,8 +15,8 @@ async function test(isError: boolean = false) {
 >x : string
 >await Promise.resolve("The test is passed without an error.") : string
 >Promise.resolve("The test is passed without an error.") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"The test is passed without an error." : "The test is passed without an error."
 }
diff --git a/tests/baselines/reference/promisePermutations.errors.txt b/tests/baselines/reference/promisePermutations.errors.txt
index 55870e072d3..46cca3191d0 100644
--- a/tests/baselines/reference/promisePermutations.errors.txt
+++ b/tests/baselines/reference/promisePermutations.errors.txt
@@ -49,7 +49,7 @@ tests/cases/compiler/promisePermutations.ts(144,35): error TS2345: Argument of t
 tests/cases/compiler/promisePermutations.ts(152,36): error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
     Types of property 'then' are incompatible.
-      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
         Types of parameters 'success' and 'onfulfilled' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'string' is not assignable to type 'number'.
@@ -64,7 +64,7 @@ tests/cases/compiler/promisePermutations.ts(159,21): error TS2345: Argument of t
 tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
         Types of parameters 'onfulfilled' and 'success' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'number' is not assignable to type 'string'.
@@ -303,7 +303,7 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of t
 !!! error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
 !!! error TS2345:   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2345:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
 !!! error TS2345:         Types of parameters 'success' and 'onfulfilled' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'string' is not assignable to type 'number'.
@@ -330,7 +330,7 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of t
 !!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 !!! error TS2345:   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
 !!! error TS2345:         Types of parameters 'onfulfilled' and 'success' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'number' is not assignable to type 'string'.
diff --git a/tests/baselines/reference/promisePermutations2.errors.txt b/tests/baselines/reference/promisePermutations2.errors.txt
index a849d444e20..767d48de30b 100644
--- a/tests/baselines/reference/promisePermutations2.errors.txt
+++ b/tests/baselines/reference/promisePermutations2.errors.txt
@@ -49,7 +49,7 @@ tests/cases/compiler/promisePermutations2.ts(143,35): error TS2345: Argument of
 tests/cases/compiler/promisePermutations2.ts(151,36): error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
     Types of property 'then' are incompatible.
-      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
         Types of parameters 'success' and 'onfulfilled' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'string' is not assignable to type 'number'.
@@ -64,7 +64,7 @@ tests/cases/compiler/promisePermutations2.ts(158,21): error TS2345: Argument of
 tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
         Types of parameters 'onfulfilled' and 'success' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'number' is not assignable to type 'string'.
@@ -302,7 +302,7 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
 !!! error TS2345:   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2345:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
 !!! error TS2345:         Types of parameters 'success' and 'onfulfilled' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'string' is not assignable to type 'number'.
@@ -329,7 +329,7 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 !!! error TS2345:   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
 !!! error TS2345:         Types of parameters 'onfulfilled' and 'success' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'number' is not assignable to type 'string'.
diff --git a/tests/baselines/reference/promisePermutations3.errors.txt b/tests/baselines/reference/promisePermutations3.errors.txt
index 94b818167c0..73917b67669 100644
--- a/tests/baselines/reference/promisePermutations3.errors.txt
+++ b/tests/baselines/reference/promisePermutations3.errors.txt
@@ -52,7 +52,7 @@ tests/cases/compiler/promisePermutations3.ts(143,35): error TS2345: Argument of
 tests/cases/compiler/promisePermutations3.ts(151,36): error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
     Types of property 'then' are incompatible.
-      Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+      Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
         Types of parameters 'success' and 'onfulfilled' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'string' is not assignable to type 'number'.
@@ -67,14 +67,14 @@ tests/cases/compiler/promisePermutations3.ts(158,21): error TS2345: Argument of
 tests/cases/compiler/promisePermutations3.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
+      Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
         Types of parameters 'onfulfilled' and 'success' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'number' is not assignable to type 'string'.
 tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of type '{ <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }' is not assignable to parameter of type '(value: (x: any) => any) => Promise<any>'.
   Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
     Types of property 'then' are incompatible.
-      Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+      Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
         Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
 
 
@@ -314,7 +314,7 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '(x: any) => IPromise<string>' is not assignable to parameter of type '(error: any) => Promise<number>'.
 !!! error TS2345:   Type 'IPromise<string>' is not assignable to type 'Promise<number>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2345:       Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
 !!! error TS2345:         Types of parameters 'success' and 'onfulfilled' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'string' is not assignable to type 'number'.
@@ -341,7 +341,7 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 !!! error TS2345:   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
+!!! error TS2345:       Type '{ <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
 !!! error TS2345:         Types of parameters 'onfulfilled' and 'success' are incompatible.
 !!! error TS2345:           Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:             Type 'number' is not assignable to type 'string'.
@@ -355,6 +355,6 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '{ <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }' is not assignable to parameter of type '(value: (x: any) => any) => Promise<any>'.
 !!! error TS2345:   Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2345:       Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
 !!! error TS2345:         Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
     var s12c = s12.then(testFunction12P, testFunction12, testFunction12); // ok
\ No newline at end of file
diff --git a/tests/baselines/reference/promiseTest.types b/tests/baselines/reference/promiseTest.types
index 2b5aaa9af88..4a86cea6994 100644
--- a/tests/baselines/reference/promiseTest.types
+++ b/tests/baselines/reference/promiseTest.types
@@ -4,7 +4,7 @@ interface Promise<T> {
 >T : T
 
     then<A>(success?: (value: T) => Promise<A>): Promise<A>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: promised T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
 >A : A
 >success : (value: T) => Promise<A>
 >value : T
@@ -15,7 +15,7 @@ interface Promise<T> {
 >A : A
 
     then<B>(success?: (value: T) => B): Promise<B>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: promised T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
 >B : B
 >success : (value: T) => B
 >value : T
@@ -37,9 +37,9 @@ var p: Promise<number> = null;
 var p2 = p.then(function (x) {
 >p2 : Promise<number>
 >p.then(function (x) {    return p;} ) : Promise<number>
->p.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
+>p.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
 >p : Promise<number>
->then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
+>then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
 >function (x) {    return p;} : (x: number) => Promise<number>
 >x : number
 
diff --git a/tests/baselines/reference/promiseType.types b/tests/baselines/reference/promiseType.types
index 8e7b10245b9..bc4ed1c18b9 100644
--- a/tests/baselines/reference/promiseType.types
+++ b/tests/baselines/reference/promiseType.types
@@ -105,9 +105,9 @@ async function F() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -170,9 +170,9 @@ async function I() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -183,231 +183,231 @@ async function I() {
 const p00 = p.catch();
 >p00 : Promise<boolean>
 >p.catch() : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 
 const p01 = p.then();
 >p01 : Promise<boolean>
 >p.then() : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 
 const p10 = p.catch(undefined);
 >p10 : Promise<boolean>
 >p.catch(undefined) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >undefined : undefined
 
 const p11 = p.catch(null);
 >p11 : Promise<boolean>
 >p.catch(null) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >null : null
 
 const p12 = p.catch(() => 1);
 >p12 : Promise<number | boolean>
 >p.catch(() => 1) : Promise<number | boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => 1 : () => number
 >1 : 1
 
 const p13 = p.catch(() => x);
 >p13 : Promise<any>
 >p.catch(() => x) : Promise<any>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => x : () => any
 >x : any
 
 const p14 = p.catch(() => undefined);
 >p14 : Promise<any>
 >p.catch(() => undefined) : Promise<any>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => undefined : () => any
 >undefined : undefined
 
 const p15 = p.catch(() => null);
 >p15 : Promise<any>
 >p.catch(() => null) : Promise<any>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => null : () => any
 >null : null
 
 const p16 = p.catch(() => {});
 >p16 : Promise<boolean | void>
 >p.catch(() => {}) : Promise<boolean | void>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => {} : () => void
 
 const p17 = p.catch(() => {throw 1});
 >p17 : Promise<boolean>
 >p.catch(() => {throw 1}) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => {throw 1} : () => never
 >1 : 1
 
 const p18 = p.catch(() => Promise.reject(1));
 >p18 : Promise<boolean>
 >p.catch(() => Promise.reject(1)) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p19 = p.catch(() => Promise.resolve(1));
 >p19 : Promise<number | boolean>
 >p.catch(() => Promise.resolve(1)) : Promise<number | boolean>
->p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: (reason: any) => TResult) => Promise<boolean | awaited TResult>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p20 = p.then(undefined);
 >p20 : Promise<boolean>
 >p.then(undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 
 const p21 = p.then(null);
 >p21 : Promise<boolean>
 >p.then(null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 
 const p22 = p.then(() => 1);
 >p22 : Promise<number>
 >p.then(() => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => 1 : () => number
 >1 : 1
 
 const p23 = p.then(() => x);
 >p23 : Promise<any>
 >p.then(() => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 
 const p24 = p.then(() => undefined);
 >p24 : Promise<any>
 >p.then(() => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 
 const p25 = p.then(() => null);
 >p25 : Promise<any>
 >p.then(() => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 
 const p26 = p.then(() => {});
 >p26 : Promise<void>
 >p.then(() => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 
 const p27 = p.then(() => {throw 1});
 >p27 : Promise<never>
 >p.then(() => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 
 const p28 = p.then(() => Promise.resolve(1));
 >p28 : Promise<number>
 >p.then(() => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p29 = p.then(() => Promise.reject(1));
 >p29 : Promise<never>
 >p.then(() => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p30 = p.then(undefined, undefined);
 >p30 : Promise<boolean>
 >p.then(undefined, undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >undefined : undefined
 
 const p31 = p.then(undefined, null);
 >p31 : Promise<boolean>
 >p.then(undefined, null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >null : null
 
 const p32 = p.then(undefined, () => 1);
 >p32 : Promise<number | boolean>
 >p.then(undefined, () => 1) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => 1 : () => number
 >1 : 1
@@ -415,9 +415,9 @@ const p32 = p.then(undefined, () => 1);
 const p33 = p.then(undefined, () => x);
 >p33 : Promise<any>
 >p.then(undefined, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => x : () => any
 >x : any
@@ -425,9 +425,9 @@ const p33 = p.then(undefined, () => x);
 const p34 = p.then(undefined, () => undefined);
 >p34 : Promise<any>
 >p.then(undefined, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => undefined : () => any
 >undefined : undefined
@@ -435,9 +435,9 @@ const p34 = p.then(undefined, () => undefined);
 const p35 = p.then(undefined, () => null);
 >p35 : Promise<any>
 >p.then(undefined, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => null : () => any
 >null : null
@@ -445,18 +445,18 @@ const p35 = p.then(undefined, () => null);
 const p36 = p.then(undefined, () => {});
 >p36 : Promise<boolean | void>
 >p.then(undefined, () => {}) : Promise<boolean | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => {} : () => void
 
 const p37 = p.then(undefined, () => {throw 1});
 >p37 : Promise<boolean>
 >p.then(undefined, () => {throw 1}) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => {throw 1} : () => never
 >1 : 1
@@ -464,55 +464,55 @@ const p37 = p.then(undefined, () => {throw 1});
 const p38 = p.then(undefined, () => Promise.resolve(1));
 >p38 : Promise<number | boolean>
 >p.then(undefined, () => Promise.resolve(1)) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p39 = p.then(undefined, () => Promise.reject(1));
 >p39 : Promise<boolean>
 >p.then(undefined, () => Promise.reject(1)) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p40 = p.then(null, undefined);
 >p40 : Promise<boolean>
 >p.then(null, undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >undefined : undefined
 
 const p41 = p.then(null, null);
 >p41 : Promise<boolean>
 >p.then(null, null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >null : null
 
 const p42 = p.then(null, () => 1);
 >p42 : Promise<number | boolean>
 >p.then(null, () => 1) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => 1 : () => number
 >1 : 1
@@ -520,9 +520,9 @@ const p42 = p.then(null, () => 1);
 const p43 = p.then(null, () => x);
 >p43 : Promise<any>
 >p.then(null, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => x : () => any
 >x : any
@@ -530,9 +530,9 @@ const p43 = p.then(null, () => x);
 const p44 = p.then(null, () => undefined);
 >p44 : Promise<any>
 >p.then(null, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => undefined : () => any
 >undefined : undefined
@@ -540,9 +540,9 @@ const p44 = p.then(null, () => undefined);
 const p45 = p.then(null, () => null);
 >p45 : Promise<any>
 >p.then(null, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => null : () => any
 >null : null
@@ -550,18 +550,18 @@ const p45 = p.then(null, () => null);
 const p46 = p.then(null, () => {});
 >p46 : Promise<boolean | void>
 >p.then(null, () => {}) : Promise<boolean | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => {} : () => void
 
 const p47 = p.then(null, () => {throw 1});
 >p47 : Promise<boolean>
 >p.then(null, () => {throw 1}) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => {throw 1} : () => never
 >1 : 1
@@ -569,37 +569,37 @@ const p47 = p.then(null, () => {throw 1});
 const p48 = p.then(null, () => Promise.resolve(1));
 >p48 : Promise<number | boolean>
 >p.then(null, () => Promise.resolve(1)) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p49 = p.then(null, () => Promise.reject(1));
 >p49 : Promise<boolean>
 >p.then(null, () => Promise.reject(1)) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p50 = p.then(() => "1", undefined);
 >p50 : Promise<string>
 >p.then(() => "1", undefined) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >undefined : undefined
@@ -607,9 +607,9 @@ const p50 = p.then(() => "1", undefined);
 const p51 = p.then(() => "1", null);
 >p51 : Promise<string>
 >p.then(() => "1", null) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >null : null
@@ -617,9 +617,9 @@ const p51 = p.then(() => "1", null);
 const p52 = p.then(() => "1", () => 1);
 >p52 : Promise<string | number>
 >p.then(() => "1", () => 1) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => 1 : () => number
@@ -628,9 +628,9 @@ const p52 = p.then(() => "1", () => 1);
 const p53 = p.then(() => "1", () => x);
 >p53 : Promise<any>
 >p.then(() => "1", () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => x : () => any
@@ -639,9 +639,9 @@ const p53 = p.then(() => "1", () => x);
 const p54 = p.then(() => "1", () => undefined);
 >p54 : Promise<any>
 >p.then(() => "1", () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => undefined : () => any
@@ -650,9 +650,9 @@ const p54 = p.then(() => "1", () => undefined);
 const p55 = p.then(() => "1", () => null);
 >p55 : Promise<any>
 >p.then(() => "1", () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => null : () => any
@@ -661,9 +661,9 @@ const p55 = p.then(() => "1", () => null);
 const p56 = p.then(() => "1", () => {});
 >p56 : Promise<string | void>
 >p.then(() => "1", () => {}) : Promise<string | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => {} : () => void
@@ -671,9 +671,9 @@ const p56 = p.then(() => "1", () => {});
 const p57 = p.then(() => "1", () => {throw 1});
 >p57 : Promise<string>
 >p.then(() => "1", () => {throw 1}) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => {throw 1} : () => never
@@ -682,39 +682,39 @@ const p57 = p.then(() => "1", () => {throw 1});
 const p58 = p.then(() => "1", () => Promise.resolve(1));
 >p58 : Promise<string | number>
 >p.then(() => "1", () => Promise.resolve(1)) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p59 = p.then(() => "1", () => Promise.reject(1));
 >p59 : Promise<string>
 >p.then(() => "1", () => Promise.reject(1)) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p60 = p.then(() => x, undefined);
 >p60 : Promise<any>
 >p.then(() => x, undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >undefined : undefined
@@ -722,9 +722,9 @@ const p60 = p.then(() => x, undefined);
 const p61 = p.then(() => x, null);
 >p61 : Promise<any>
 >p.then(() => x, null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >null : null
@@ -732,9 +732,9 @@ const p61 = p.then(() => x, null);
 const p62 = p.then(() => x, () => 1);
 >p62 : Promise<any>
 >p.then(() => x, () => 1) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => 1 : () => number
@@ -743,9 +743,9 @@ const p62 = p.then(() => x, () => 1);
 const p63 = p.then(() => x, () => x);
 >p63 : Promise<any>
 >p.then(() => x, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => x : () => any
@@ -754,9 +754,9 @@ const p63 = p.then(() => x, () => x);
 const p64 = p.then(() => x, () => undefined);
 >p64 : Promise<any>
 >p.then(() => x, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => undefined : () => any
@@ -765,9 +765,9 @@ const p64 = p.then(() => x, () => undefined);
 const p65 = p.then(() => x, () => null);
 >p65 : Promise<any>
 >p.then(() => x, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => null : () => any
@@ -776,9 +776,9 @@ const p65 = p.then(() => x, () => null);
 const p66 = p.then(() => x, () => {});
 >p66 : Promise<any>
 >p.then(() => x, () => {}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => {} : () => void
@@ -786,9 +786,9 @@ const p66 = p.then(() => x, () => {});
 const p67 = p.then(() => x, () => {throw 1});
 >p67 : Promise<any>
 >p.then(() => x, () => {throw 1}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => {throw 1} : () => never
@@ -797,39 +797,39 @@ const p67 = p.then(() => x, () => {throw 1});
 const p68 = p.then(() => x, () => Promise.resolve(1));
 >p68 : Promise<any>
 >p.then(() => x, () => Promise.resolve(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p69 = p.then(() => x, () => Promise.reject(1));
 >p69 : Promise<any>
 >p.then(() => x, () => Promise.reject(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p70 = p.then(() => undefined, undefined);
 >p70 : Promise<any>
 >p.then(() => undefined, undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >undefined : undefined
@@ -837,9 +837,9 @@ const p70 = p.then(() => undefined, undefined);
 const p71 = p.then(() => undefined, null);
 >p71 : Promise<any>
 >p.then(() => undefined, null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >null : null
@@ -847,9 +847,9 @@ const p71 = p.then(() => undefined, null);
 const p72 = p.then(() => undefined, () => 1);
 >p72 : Promise<any>
 >p.then(() => undefined, () => 1) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => 1 : () => number
@@ -858,9 +858,9 @@ const p72 = p.then(() => undefined, () => 1);
 const p73 = p.then(() => undefined, () => x);
 >p73 : Promise<any>
 >p.then(() => undefined, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => x : () => any
@@ -869,9 +869,9 @@ const p73 = p.then(() => undefined, () => x);
 const p74 = p.then(() => undefined, () => undefined);
 >p74 : Promise<any>
 >p.then(() => undefined, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => undefined : () => any
@@ -880,9 +880,9 @@ const p74 = p.then(() => undefined, () => undefined);
 const p75 = p.then(() => undefined, () => null);
 >p75 : Promise<any>
 >p.then(() => undefined, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => null : () => any
@@ -891,9 +891,9 @@ const p75 = p.then(() => undefined, () => null);
 const p76 = p.then(() => undefined, () => {});
 >p76 : Promise<any>
 >p.then(() => undefined, () => {}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => {} : () => void
@@ -901,9 +901,9 @@ const p76 = p.then(() => undefined, () => {});
 const p77 = p.then(() => undefined, () => {throw 1});
 >p77 : Promise<any>
 >p.then(() => undefined, () => {throw 1}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => {throw 1} : () => never
@@ -912,39 +912,39 @@ const p77 = p.then(() => undefined, () => {throw 1});
 const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >p78 : Promise<any>
 >p.then(() => undefined, () => Promise.resolve(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p79 = p.then(() => undefined, () => Promise.reject(1));
 >p79 : Promise<any>
 >p.then(() => undefined, () => Promise.reject(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => any
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p80 = p.then(() => null, undefined);
 >p80 : Promise<any>
 >p.then(() => null, undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >undefined : undefined
@@ -952,9 +952,9 @@ const p80 = p.then(() => null, undefined);
 const p81 = p.then(() => null, null);
 >p81 : Promise<any>
 >p.then(() => null, null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >null : null
@@ -962,9 +962,9 @@ const p81 = p.then(() => null, null);
 const p82 = p.then(() => null, () => 1);
 >p82 : Promise<any>
 >p.then(() => null, () => 1) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => 1 : () => number
@@ -973,9 +973,9 @@ const p82 = p.then(() => null, () => 1);
 const p83 = p.then(() => null, () => x);
 >p83 : Promise<any>
 >p.then(() => null, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => x : () => any
@@ -984,9 +984,9 @@ const p83 = p.then(() => null, () => x);
 const p84 = p.then(() => null, () => undefined);
 >p84 : Promise<any>
 >p.then(() => null, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => undefined : () => any
@@ -995,9 +995,9 @@ const p84 = p.then(() => null, () => undefined);
 const p85 = p.then(() => null, () => null);
 >p85 : Promise<any>
 >p.then(() => null, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => null : () => any
@@ -1006,9 +1006,9 @@ const p85 = p.then(() => null, () => null);
 const p86 = p.then(() => null, () => {});
 >p86 : Promise<any>
 >p.then(() => null, () => {}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => {} : () => void
@@ -1016,9 +1016,9 @@ const p86 = p.then(() => null, () => {});
 const p87 = p.then(() => null, () => {throw 1});
 >p87 : Promise<any>
 >p.then(() => null, () => {throw 1}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => {throw 1} : () => never
@@ -1027,57 +1027,57 @@ const p87 = p.then(() => null, () => {throw 1});
 const p88 = p.then(() => null, () => Promise.resolve(1));
 >p88 : Promise<any>
 >p.then(() => null, () => Promise.resolve(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p89 = p.then(() => null, () => Promise.reject(1));
 >p89 : Promise<any>
 >p.then(() => null, () => Promise.reject(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => any
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p90 = p.then(() => {}, undefined);
 >p90 : Promise<void>
 >p.then(() => {}, undefined) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >undefined : undefined
 
 const p91 = p.then(() => {}, null);
 >p91 : Promise<void>
 >p.then(() => {}, null) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >null : null
 
 const p92 = p.then(() => {}, () => 1);
 >p92 : Promise<number | void>
 >p.then(() => {}, () => 1) : Promise<number | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => 1 : () => number
 >1 : 1
@@ -1085,9 +1085,9 @@ const p92 = p.then(() => {}, () => 1);
 const p93 = p.then(() => {}, () => x);
 >p93 : Promise<any>
 >p.then(() => {}, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => x : () => any
 >x : any
@@ -1095,9 +1095,9 @@ const p93 = p.then(() => {}, () => x);
 const p94 = p.then(() => {}, () => undefined);
 >p94 : Promise<any>
 >p.then(() => {}, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => undefined : () => any
 >undefined : undefined
@@ -1105,9 +1105,9 @@ const p94 = p.then(() => {}, () => undefined);
 const p95 = p.then(() => {}, () => null);
 >p95 : Promise<any>
 >p.then(() => {}, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => null : () => any
 >null : null
@@ -1115,18 +1115,18 @@ const p95 = p.then(() => {}, () => null);
 const p96 = p.then(() => {}, () => {});
 >p96 : Promise<void>
 >p.then(() => {}, () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => {} : () => void
 
 const p97 = p.then(() => {}, () => {throw 1});
 >p97 : Promise<void>
 >p.then(() => {}, () => {throw 1}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => {throw 1} : () => never
 >1 : 1
@@ -1134,37 +1134,37 @@ const p97 = p.then(() => {}, () => {throw 1});
 const p98 = p.then(() => {}, () => Promise.resolve(1));
 >p98 : Promise<number | void>
 >p.then(() => {}, () => Promise.resolve(1)) : Promise<number | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p99 = p.then(() => {}, () => Promise.reject(1));
 >p99 : Promise<void>
 >p.then(() => {}, () => Promise.reject(1)) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pa0 = p.then(() => {throw 1}, undefined);
 >pa0 : Promise<never>
 >p.then(() => {throw 1}, undefined) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >undefined : undefined
@@ -1172,9 +1172,9 @@ const pa0 = p.then(() => {throw 1}, undefined);
 const pa1 = p.then(() => {throw 1}, null);
 >pa1 : Promise<never>
 >p.then(() => {throw 1}, null) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >null : null
@@ -1182,9 +1182,9 @@ const pa1 = p.then(() => {throw 1}, null);
 const pa2 = p.then(() => {throw 1}, () => 1);
 >pa2 : Promise<number>
 >p.then(() => {throw 1}, () => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => 1 : () => number
@@ -1193,9 +1193,9 @@ const pa2 = p.then(() => {throw 1}, () => 1);
 const pa3 = p.then(() => {throw 1}, () => x);
 >pa3 : Promise<any>
 >p.then(() => {throw 1}, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => x : () => any
@@ -1204,9 +1204,9 @@ const pa3 = p.then(() => {throw 1}, () => x);
 const pa4 = p.then(() => {throw 1}, () => undefined);
 >pa4 : Promise<any>
 >p.then(() => {throw 1}, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => undefined : () => any
@@ -1215,9 +1215,9 @@ const pa4 = p.then(() => {throw 1}, () => undefined);
 const pa5 = p.then(() => {throw 1}, () => null);
 >pa5 : Promise<any>
 >p.then(() => {throw 1}, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => null : () => any
@@ -1226,9 +1226,9 @@ const pa5 = p.then(() => {throw 1}, () => null);
 const pa6 = p.then(() => {throw 1}, () => {});
 >pa6 : Promise<void>
 >p.then(() => {throw 1}, () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => {} : () => void
@@ -1236,9 +1236,9 @@ const pa6 = p.then(() => {throw 1}, () => {});
 const pa7 = p.then(() => {throw 1}, () => {throw 1});
 >pa7 : Promise<never>
 >p.then(() => {throw 1}, () => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => {throw 1} : () => never
@@ -1247,72 +1247,72 @@ const pa7 = p.then(() => {throw 1}, () => {throw 1});
 const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >pa8 : Promise<number>
 >p.then(() => {throw 1}, () => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
 >pa9 : Promise<never>
 >p.then(() => {throw 1}, () => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >pb0 : Promise<string>
 >p.then(() => Promise.resolve("1"), undefined) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >undefined : undefined
 
 const pb1 = p.then(() => Promise.resolve("1"), null);
 >pb1 : Promise<string>
 >p.then(() => Promise.resolve("1"), null) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >null : null
 
 const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >pb2 : Promise<string | number>
 >p.then(() => Promise.resolve("1"), () => 1) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1320,14 +1320,14 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >pb3 : Promise<any>
 >p.then(() => Promise.resolve("1"), () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1335,14 +1335,14 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x);
 const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >pb4 : Promise<any>
 >p.then(() => Promise.resolve("1"), () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => undefined : () => any
 >undefined : undefined
@@ -1350,14 +1350,14 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >pb5 : Promise<any>
 >p.then(() => Promise.resolve("1"), () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => null : () => any
 >null : null
@@ -1365,28 +1365,28 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null);
 const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >pb6 : Promise<string | void>
 >p.then(() => Promise.resolve("1"), () => {}) : Promise<string | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => {} : () => void
 
 const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >pb7 : Promise<string>
 >p.then(() => Promise.resolve("1"), () => {throw 1}) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1394,80 +1394,80 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >pb8 : Promise<string | number>
 >p.then(() => Promise.resolve("1"), () => Promise.resolve(1)) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >pb9 : Promise<string>
 >p.then(() => Promise.resolve("1"), () => Promise.reject(1)) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pc0 = p.then(() => Promise.reject("1"), undefined);
 >pc0 : Promise<never>
 >p.then(() => Promise.reject("1"), undefined) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >undefined : undefined
 
 const pc1 = p.then(() => Promise.reject("1"), null);
 >pc1 : Promise<never>
 >p.then(() => Promise.reject("1"), null) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >null : null
 
 const pc2 = p.then(() => Promise.reject("1"), () => 1);
 >pc2 : Promise<number>
 >p.then(() => Promise.reject("1"), () => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1475,14 +1475,14 @@ const pc2 = p.then(() => Promise.reject("1"), () => 1);
 const pc3 = p.then(() => Promise.reject("1"), () => x);
 >pc3 : Promise<any>
 >p.then(() => Promise.reject("1"), () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1490,14 +1490,14 @@ const pc3 = p.then(() => Promise.reject("1"), () => x);
 const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 >pc4 : Promise<any>
 >p.then(() => Promise.reject("1"), () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => undefined : () => any
 >undefined : undefined
@@ -1505,14 +1505,14 @@ const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 const pc5 = p.then(() => Promise.reject("1"), () => null);
 >pc5 : Promise<any>
 >p.then(() => Promise.reject("1"), () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => null : () => any
 >null : null
@@ -1520,28 +1520,28 @@ const pc5 = p.then(() => Promise.reject("1"), () => null);
 const pc6 = p.then(() => Promise.reject("1"), () => {});
 >pc6 : Promise<void>
 >p.then(() => Promise.reject("1"), () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => {} : () => void
 
 const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 >pc7 : Promise<never>
 >p.then(() => Promise.reject("1"), () => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1549,38 +1549,38 @@ const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >pc8 : Promise<number>
 >p.then(() => Promise.reject("1"), () => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >pc9 : Promise<never>
 >p.then(() => Promise.reject("1"), () => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
diff --git a/tests/baselines/reference/promiseTypeInference.types b/tests/baselines/reference/promiseTypeInference.types
index f8797948023..cbcdc84b782 100644
--- a/tests/baselines/reference/promiseTypeInference.types
+++ b/tests/baselines/reference/promiseTypeInference.types
@@ -4,7 +4,7 @@ declare class Promise<T> {
 >T : T
 
     then<U>(success?: (value: T) => Promise<U>): Promise<U>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: promised T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
 >U : U
 >success : (value: T) => Promise<U>
 >value : T
@@ -42,11 +42,11 @@ declare function convert(s: string): IPromise<number>;
 var $$x = load("something").then(s => convert(s));
 >$$x : Promise<number>
 >load("something").then(s => convert(s)) : Promise<number>
->load("something").then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: string) => Promise<U>): Promise<U>; }
+>load("something").then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>): Promise<U>; }
 >load("something") : Promise<string>
 >load : (name: string) => Promise<string>
 >"something" : "something"
->then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: string) => Promise<U>): Promise<U>; }
+>then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: string) => Promise<U>): Promise<U>; }
 >s => convert(s) : (s: string) => IPromise<number>
 >s : string
 >convert(s) : IPromise<number>
diff --git a/tests/baselines/reference/promiseTypeStrictNull.types b/tests/baselines/reference/promiseTypeStrictNull.types
index b778e8356d8..be751d5dc4a 100644
--- a/tests/baselines/reference/promiseTypeStrictNull.types
+++ b/tests/baselines/reference/promiseTypeStrictNull.types
@@ -105,9 +105,9 @@ async function F() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -170,9 +170,9 @@ async function I() {
 
         return Promise.reject(Error());
 >Promise.reject(Error()) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Error() : Error
 >Error : ErrorConstructor
     }
@@ -183,231 +183,231 @@ async function I() {
 const p00 = p.catch();
 >p00 : Promise<boolean>
 >p.catch() : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 
 const p01 = p.then();
 >p01 : Promise<boolean>
 >p.then() : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 
 const p10 = p.catch(undefined);
 >p10 : Promise<boolean>
 >p.catch(undefined) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >undefined : undefined
 
 const p11 = p.catch(null);
 >p11 : Promise<boolean>
 >p.catch(null) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >null : null
 
 const p12 = p.catch(() => 1);
 >p12 : Promise<number | boolean>
 >p.catch(() => 1) : Promise<number | boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => 1 : () => number
 >1 : 1
 
 const p13 = p.catch(() => x);
 >p13 : Promise<any>
 >p.catch(() => x) : Promise<any>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => x : () => any
 >x : any
 
 const p14 = p.catch(() => undefined);
 >p14 : Promise<boolean | undefined>
 >p.catch(() => undefined) : Promise<boolean | undefined>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => undefined : () => undefined
 >undefined : undefined
 
 const p15 = p.catch(() => null);
 >p15 : Promise<boolean | null>
 >p.catch(() => null) : Promise<boolean | null>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => null : () => null
 >null : null
 
 const p16 = p.catch(() => {});
 >p16 : Promise<boolean | void>
 >p.catch(() => {}) : Promise<boolean | void>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => {} : () => void
 
 const p17 = p.catch(() => {throw 1});
 >p17 : Promise<boolean>
 >p.catch(() => {throw 1}) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => {throw 1} : () => never
 >1 : 1
 
 const p18 = p.catch(() => Promise.reject(1));
 >p18 : Promise<boolean>
 >p.catch(() => Promise.reject(1)) : Promise<boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p19 = p.catch(() => Promise.resolve(1));
 >p19 : Promise<number | boolean>
 >p.catch(() => Promise.resolve(1)) : Promise<number | boolean>
->p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >p : Promise<boolean>
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | promised TResult>
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult) | null | undefined) => Promise<boolean | awaited TResult>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p20 = p.then(undefined);
 >p20 : Promise<boolean>
 >p.then(undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 
 const p21 = p.then(null);
 >p21 : Promise<boolean>
 >p.then(null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 
 const p22 = p.then(() => 1);
 >p22 : Promise<number>
 >p.then(() => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => 1 : () => number
 >1 : 1
 
 const p23 = p.then(() => x);
 >p23 : Promise<any>
 >p.then(() => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 
 const p24 = p.then(() => undefined);
 >p24 : Promise<undefined>
 >p.then(() => undefined) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 
 const p25 = p.then(() => null);
 >p25 : Promise<null>
 >p.then(() => null) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 
 const p26 = p.then(() => {});
 >p26 : Promise<void>
 >p.then(() => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 
 const p27 = p.then(() => {throw 1});
 >p27 : Promise<never>
 >p.then(() => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 
 const p28 = p.then(() => Promise.resolve(1));
 >p28 : Promise<number>
 >p.then(() => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p29 = p.then(() => Promise.reject(1));
 >p29 : Promise<never>
 >p.then(() => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p30 = p.then(undefined, undefined);
 >p30 : Promise<boolean>
 >p.then(undefined, undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >undefined : undefined
 
 const p31 = p.then(undefined, null);
 >p31 : Promise<boolean>
 >p.then(undefined, null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >null : null
 
 const p32 = p.then(undefined, () => 1);
 >p32 : Promise<number | boolean>
 >p.then(undefined, () => 1) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => 1 : () => number
 >1 : 1
@@ -415,9 +415,9 @@ const p32 = p.then(undefined, () => 1);
 const p33 = p.then(undefined, () => x);
 >p33 : Promise<any>
 >p.then(undefined, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => x : () => any
 >x : any
@@ -425,9 +425,9 @@ const p33 = p.then(undefined, () => x);
 const p34 = p.then(undefined, () => undefined);
 >p34 : Promise<boolean | undefined>
 >p.then(undefined, () => undefined) : Promise<boolean | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => undefined : () => undefined
 >undefined : undefined
@@ -435,9 +435,9 @@ const p34 = p.then(undefined, () => undefined);
 const p35 = p.then(undefined, () => null);
 >p35 : Promise<boolean | null>
 >p.then(undefined, () => null) : Promise<boolean | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => null : () => null
 >null : null
@@ -445,18 +445,18 @@ const p35 = p.then(undefined, () => null);
 const p36 = p.then(undefined, () => {});
 >p36 : Promise<boolean | void>
 >p.then(undefined, () => {}) : Promise<boolean | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => {} : () => void
 
 const p37 = p.then(undefined, () => {throw 1});
 >p37 : Promise<boolean>
 >p.then(undefined, () => {throw 1}) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => {throw 1} : () => never
 >1 : 1
@@ -464,55 +464,55 @@ const p37 = p.then(undefined, () => {throw 1});
 const p38 = p.then(undefined, () => Promise.resolve(1));
 >p38 : Promise<number | boolean>
 >p.then(undefined, () => Promise.resolve(1)) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p39 = p.then(undefined, () => Promise.reject(1));
 >p39 : Promise<boolean>
 >p.then(undefined, () => Promise.reject(1)) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p40 = p.then(null, undefined);
 >p40 : Promise<boolean>
 >p.then(null, undefined) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >undefined : undefined
 
 const p41 = p.then(null, null);
 >p41 : Promise<boolean>
 >p.then(null, null) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >null : null
 
 const p42 = p.then(null, () => 1);
 >p42 : Promise<number | boolean>
 >p.then(null, () => 1) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => 1 : () => number
 >1 : 1
@@ -520,9 +520,9 @@ const p42 = p.then(null, () => 1);
 const p43 = p.then(null, () => x);
 >p43 : Promise<any>
 >p.then(null, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => x : () => any
 >x : any
@@ -530,9 +530,9 @@ const p43 = p.then(null, () => x);
 const p44 = p.then(null, () => undefined);
 >p44 : Promise<boolean | undefined>
 >p.then(null, () => undefined) : Promise<boolean | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => undefined : () => undefined
 >undefined : undefined
@@ -540,9 +540,9 @@ const p44 = p.then(null, () => undefined);
 const p45 = p.then(null, () => null);
 >p45 : Promise<boolean | null>
 >p.then(null, () => null) : Promise<boolean | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => null : () => null
 >null : null
@@ -550,18 +550,18 @@ const p45 = p.then(null, () => null);
 const p46 = p.then(null, () => {});
 >p46 : Promise<boolean | void>
 >p.then(null, () => {}) : Promise<boolean | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => {} : () => void
 
 const p47 = p.then(null, () => {throw 1});
 >p47 : Promise<boolean>
 >p.then(null, () => {throw 1}) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => {throw 1} : () => never
 >1 : 1
@@ -569,37 +569,37 @@ const p47 = p.then(null, () => {throw 1});
 const p48 = p.then(null, () => Promise.resolve(1));
 >p48 : Promise<number | boolean>
 >p.then(null, () => Promise.resolve(1)) : Promise<number | boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p49 = p.then(null, () => Promise.reject(1));
 >p49 : Promise<boolean>
 >p.then(null, () => Promise.reject(1)) : Promise<boolean>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p50 = p.then(() => "1", undefined);
 >p50 : Promise<string>
 >p.then(() => "1", undefined) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >undefined : undefined
@@ -607,9 +607,9 @@ const p50 = p.then(() => "1", undefined);
 const p51 = p.then(() => "1", null);
 >p51 : Promise<string>
 >p.then(() => "1", null) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >null : null
@@ -617,9 +617,9 @@ const p51 = p.then(() => "1", null);
 const p52 = p.then(() => "1", () => 1);
 >p52 : Promise<string | number>
 >p.then(() => "1", () => 1) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => 1 : () => number
@@ -628,9 +628,9 @@ const p52 = p.then(() => "1", () => 1);
 const p53 = p.then(() => "1", () => x);
 >p53 : Promise<any>
 >p.then(() => "1", () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => x : () => any
@@ -639,9 +639,9 @@ const p53 = p.then(() => "1", () => x);
 const p54 = p.then(() => "1", () => undefined);
 >p54 : Promise<string | undefined>
 >p.then(() => "1", () => undefined) : Promise<string | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => undefined : () => undefined
@@ -650,9 +650,9 @@ const p54 = p.then(() => "1", () => undefined);
 const p55 = p.then(() => "1", () => null);
 >p55 : Promise<string | null>
 >p.then(() => "1", () => null) : Promise<string | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => null : () => null
@@ -661,9 +661,9 @@ const p55 = p.then(() => "1", () => null);
 const p56 = p.then(() => "1", () => {});
 >p56 : Promise<string | void>
 >p.then(() => "1", () => {}) : Promise<string | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => {} : () => void
@@ -671,9 +671,9 @@ const p56 = p.then(() => "1", () => {});
 const p57 = p.then(() => "1", () => {throw 1});
 >p57 : Promise<string>
 >p.then(() => "1", () => {throw 1}) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => {throw 1} : () => never
@@ -682,39 +682,39 @@ const p57 = p.then(() => "1", () => {throw 1});
 const p58 = p.then(() => "1", () => Promise.resolve(1));
 >p58 : Promise<string | number>
 >p.then(() => "1", () => Promise.resolve(1)) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p59 = p.then(() => "1", () => Promise.reject(1));
 >p59 : Promise<string>
 >p.then(() => "1", () => Promise.reject(1)) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => "1" : () => string
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p60 = p.then(() => x, undefined);
 >p60 : Promise<any>
 >p.then(() => x, undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >undefined : undefined
@@ -722,9 +722,9 @@ const p60 = p.then(() => x, undefined);
 const p61 = p.then(() => x, null);
 >p61 : Promise<any>
 >p.then(() => x, null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >null : null
@@ -732,9 +732,9 @@ const p61 = p.then(() => x, null);
 const p62 = p.then(() => x, () => 1);
 >p62 : Promise<any>
 >p.then(() => x, () => 1) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => 1 : () => number
@@ -743,9 +743,9 @@ const p62 = p.then(() => x, () => 1);
 const p63 = p.then(() => x, () => x);
 >p63 : Promise<any>
 >p.then(() => x, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => x : () => any
@@ -754,9 +754,9 @@ const p63 = p.then(() => x, () => x);
 const p64 = p.then(() => x, () => undefined);
 >p64 : Promise<any>
 >p.then(() => x, () => undefined) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => undefined : () => undefined
@@ -765,9 +765,9 @@ const p64 = p.then(() => x, () => undefined);
 const p65 = p.then(() => x, () => null);
 >p65 : Promise<any>
 >p.then(() => x, () => null) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => null : () => null
@@ -776,9 +776,9 @@ const p65 = p.then(() => x, () => null);
 const p66 = p.then(() => x, () => {});
 >p66 : Promise<any>
 >p.then(() => x, () => {}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => {} : () => void
@@ -786,9 +786,9 @@ const p66 = p.then(() => x, () => {});
 const p67 = p.then(() => x, () => {throw 1});
 >p67 : Promise<any>
 >p.then(() => x, () => {throw 1}) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => {throw 1} : () => never
@@ -797,39 +797,39 @@ const p67 = p.then(() => x, () => {throw 1});
 const p68 = p.then(() => x, () => Promise.resolve(1));
 >p68 : Promise<any>
 >p.then(() => x, () => Promise.resolve(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p69 = p.then(() => x, () => Promise.reject(1));
 >p69 : Promise<any>
 >p.then(() => x, () => Promise.reject(1)) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => x : () => any
 >x : any
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p70 = p.then(() => undefined, undefined);
 >p70 : Promise<undefined>
 >p.then(() => undefined, undefined) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >undefined : undefined
@@ -837,9 +837,9 @@ const p70 = p.then(() => undefined, undefined);
 const p71 = p.then(() => undefined, null);
 >p71 : Promise<undefined>
 >p.then(() => undefined, null) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >null : null
@@ -847,9 +847,9 @@ const p71 = p.then(() => undefined, null);
 const p72 = p.then(() => undefined, () => 1);
 >p72 : Promise<number | undefined>
 >p.then(() => undefined, () => 1) : Promise<number | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => 1 : () => number
@@ -858,9 +858,9 @@ const p72 = p.then(() => undefined, () => 1);
 const p73 = p.then(() => undefined, () => x);
 >p73 : Promise<any>
 >p.then(() => undefined, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => x : () => any
@@ -869,9 +869,9 @@ const p73 = p.then(() => undefined, () => x);
 const p74 = p.then(() => undefined, () => undefined);
 >p74 : Promise<undefined>
 >p.then(() => undefined, () => undefined) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => undefined : () => undefined
@@ -880,9 +880,9 @@ const p74 = p.then(() => undefined, () => undefined);
 const p75 = p.then(() => undefined, () => null);
 >p75 : Promise<null | undefined>
 >p.then(() => undefined, () => null) : Promise<null | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => null : () => null
@@ -891,9 +891,9 @@ const p75 = p.then(() => undefined, () => null);
 const p76 = p.then(() => undefined, () => {});
 >p76 : Promise<void | undefined>
 >p.then(() => undefined, () => {}) : Promise<void | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => {} : () => void
@@ -901,9 +901,9 @@ const p76 = p.then(() => undefined, () => {});
 const p77 = p.then(() => undefined, () => {throw 1});
 >p77 : Promise<undefined>
 >p.then(() => undefined, () => {throw 1}) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => {throw 1} : () => never
@@ -912,39 +912,39 @@ const p77 = p.then(() => undefined, () => {throw 1});
 const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >p78 : Promise<number | undefined>
 >p.then(() => undefined, () => Promise.resolve(1)) : Promise<number | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p79 = p.then(() => undefined, () => Promise.reject(1));
 >p79 : Promise<undefined>
 >p.then(() => undefined, () => Promise.reject(1)) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => undefined : () => undefined
 >undefined : undefined
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p80 = p.then(() => null, undefined);
 >p80 : Promise<null>
 >p.then(() => null, undefined) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >undefined : undefined
@@ -952,9 +952,9 @@ const p80 = p.then(() => null, undefined);
 const p81 = p.then(() => null, null);
 >p81 : Promise<null>
 >p.then(() => null, null) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >null : null
@@ -962,9 +962,9 @@ const p81 = p.then(() => null, null);
 const p82 = p.then(() => null, () => 1);
 >p82 : Promise<number | null>
 >p.then(() => null, () => 1) : Promise<number | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => 1 : () => number
@@ -973,9 +973,9 @@ const p82 = p.then(() => null, () => 1);
 const p83 = p.then(() => null, () => x);
 >p83 : Promise<any>
 >p.then(() => null, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => x : () => any
@@ -984,9 +984,9 @@ const p83 = p.then(() => null, () => x);
 const p84 = p.then(() => null, () => undefined);
 >p84 : Promise<null | undefined>
 >p.then(() => null, () => undefined) : Promise<null | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => undefined : () => undefined
@@ -995,9 +995,9 @@ const p84 = p.then(() => null, () => undefined);
 const p85 = p.then(() => null, () => null);
 >p85 : Promise<null>
 >p.then(() => null, () => null) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => null : () => null
@@ -1006,9 +1006,9 @@ const p85 = p.then(() => null, () => null);
 const p86 = p.then(() => null, () => {});
 >p86 : Promise<void | null>
 >p.then(() => null, () => {}) : Promise<void | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => {} : () => void
@@ -1016,9 +1016,9 @@ const p86 = p.then(() => null, () => {});
 const p87 = p.then(() => null, () => {throw 1});
 >p87 : Promise<null>
 >p.then(() => null, () => {throw 1}) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => {throw 1} : () => never
@@ -1027,57 +1027,57 @@ const p87 = p.then(() => null, () => {throw 1});
 const p88 = p.then(() => null, () => Promise.resolve(1));
 >p88 : Promise<number | null>
 >p.then(() => null, () => Promise.resolve(1)) : Promise<number | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p89 = p.then(() => null, () => Promise.reject(1));
 >p89 : Promise<null>
 >p.then(() => null, () => Promise.reject(1)) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => null : () => null
 >null : null
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const p90 = p.then(() => {}, undefined);
 >p90 : Promise<void>
 >p.then(() => {}, undefined) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >undefined : undefined
 
 const p91 = p.then(() => {}, null);
 >p91 : Promise<void>
 >p.then(() => {}, null) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >null : null
 
 const p92 = p.then(() => {}, () => 1);
 >p92 : Promise<number | void>
 >p.then(() => {}, () => 1) : Promise<number | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => 1 : () => number
 >1 : 1
@@ -1085,9 +1085,9 @@ const p92 = p.then(() => {}, () => 1);
 const p93 = p.then(() => {}, () => x);
 >p93 : Promise<any>
 >p.then(() => {}, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => x : () => any
 >x : any
@@ -1095,9 +1095,9 @@ const p93 = p.then(() => {}, () => x);
 const p94 = p.then(() => {}, () => undefined);
 >p94 : Promise<void | undefined>
 >p.then(() => {}, () => undefined) : Promise<void | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => undefined : () => undefined
 >undefined : undefined
@@ -1105,9 +1105,9 @@ const p94 = p.then(() => {}, () => undefined);
 const p95 = p.then(() => {}, () => null);
 >p95 : Promise<void | null>
 >p.then(() => {}, () => null) : Promise<void | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => null : () => null
 >null : null
@@ -1115,18 +1115,18 @@ const p95 = p.then(() => {}, () => null);
 const p96 = p.then(() => {}, () => {});
 >p96 : Promise<void>
 >p.then(() => {}, () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => {} : () => void
 
 const p97 = p.then(() => {}, () => {throw 1});
 >p97 : Promise<void>
 >p.then(() => {}, () => {throw 1}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => {throw 1} : () => never
 >1 : 1
@@ -1134,37 +1134,37 @@ const p97 = p.then(() => {}, () => {throw 1});
 const p98 = p.then(() => {}, () => Promise.resolve(1));
 >p98 : Promise<number | void>
 >p.then(() => {}, () => Promise.resolve(1)) : Promise<number | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const p99 = p.then(() => {}, () => Promise.reject(1));
 >p99 : Promise<void>
 >p.then(() => {}, () => Promise.reject(1)) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {} : () => void
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pa0 = p.then(() => {throw 1}, undefined);
 >pa0 : Promise<never>
 >p.then(() => {throw 1}, undefined) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >undefined : undefined
@@ -1172,9 +1172,9 @@ const pa0 = p.then(() => {throw 1}, undefined);
 const pa1 = p.then(() => {throw 1}, null);
 >pa1 : Promise<never>
 >p.then(() => {throw 1}, null) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >null : null
@@ -1182,9 +1182,9 @@ const pa1 = p.then(() => {throw 1}, null);
 const pa2 = p.then(() => {throw 1}, () => 1);
 >pa2 : Promise<number>
 >p.then(() => {throw 1}, () => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => 1 : () => number
@@ -1193,9 +1193,9 @@ const pa2 = p.then(() => {throw 1}, () => 1);
 const pa3 = p.then(() => {throw 1}, () => x);
 >pa3 : Promise<any>
 >p.then(() => {throw 1}, () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => x : () => any
@@ -1204,9 +1204,9 @@ const pa3 = p.then(() => {throw 1}, () => x);
 const pa4 = p.then(() => {throw 1}, () => undefined);
 >pa4 : Promise<undefined>
 >p.then(() => {throw 1}, () => undefined) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => undefined : () => undefined
@@ -1215,9 +1215,9 @@ const pa4 = p.then(() => {throw 1}, () => undefined);
 const pa5 = p.then(() => {throw 1}, () => null);
 >pa5 : Promise<null>
 >p.then(() => {throw 1}, () => null) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => null : () => null
@@ -1226,9 +1226,9 @@ const pa5 = p.then(() => {throw 1}, () => null);
 const pa6 = p.then(() => {throw 1}, () => {});
 >pa6 : Promise<void>
 >p.then(() => {throw 1}, () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => {} : () => void
@@ -1236,9 +1236,9 @@ const pa6 = p.then(() => {throw 1}, () => {});
 const pa7 = p.then(() => {throw 1}, () => {throw 1});
 >pa7 : Promise<never>
 >p.then(() => {throw 1}, () => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => {throw 1} : () => never
@@ -1247,72 +1247,72 @@ const pa7 = p.then(() => {throw 1}, () => {throw 1});
 const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >pa8 : Promise<number>
 >p.then(() => {throw 1}, () => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
 >pa9 : Promise<never>
 >p.then(() => {throw 1}, () => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => {throw 1} : () => never
 >1 : 1
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >pb0 : Promise<string>
 >p.then(() => Promise.resolve("1"), undefined) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >undefined : undefined
 
 const pb1 = p.then(() => Promise.resolve("1"), null);
 >pb1 : Promise<string>
 >p.then(() => Promise.resolve("1"), null) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >null : null
 
 const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >pb2 : Promise<string | number>
 >p.then(() => Promise.resolve("1"), () => 1) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1320,14 +1320,14 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >pb3 : Promise<any>
 >p.then(() => Promise.resolve("1"), () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1335,14 +1335,14 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x);
 const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >pb4 : Promise<string | undefined>
 >p.then(() => Promise.resolve("1"), () => undefined) : Promise<string | undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => undefined : () => undefined
 >undefined : undefined
@@ -1350,14 +1350,14 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >pb5 : Promise<string | null>
 >p.then(() => Promise.resolve("1"), () => null) : Promise<string | null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => null : () => null
 >null : null
@@ -1365,28 +1365,28 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null);
 const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >pb6 : Promise<string | void>
 >p.then(() => Promise.resolve("1"), () => {}) : Promise<string | void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => {} : () => void
 
 const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >pb7 : Promise<string>
 >p.then(() => Promise.resolve("1"), () => {throw 1}) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1394,80 +1394,80 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >pb8 : Promise<string | number>
 >p.then(() => Promise.resolve("1"), () => Promise.resolve(1)) : Promise<string | number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >pb9 : Promise<string>
 >p.then(() => Promise.resolve("1"), () => Promise.reject(1)) : Promise<string>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.resolve("1") : () => Promise<string>
 >Promise.resolve("1") : Promise<string>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
 const pc0 = p.then(() => Promise.reject("1"), undefined);
 >pc0 : Promise<never>
 >p.then(() => Promise.reject("1"), undefined) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >undefined : undefined
 
 const pc1 = p.then(() => Promise.reject("1"), null);
 >pc1 : Promise<never>
 >p.then(() => Promise.reject("1"), null) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >null : null
 
 const pc2 = p.then(() => Promise.reject("1"), () => 1);
 >pc2 : Promise<number>
 >p.then(() => Promise.reject("1"), () => 1) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => 1 : () => number
 >1 : 1
@@ -1475,14 +1475,14 @@ const pc2 = p.then(() => Promise.reject("1"), () => 1);
 const pc3 = p.then(() => Promise.reject("1"), () => x);
 >pc3 : Promise<any>
 >p.then(() => Promise.reject("1"), () => x) : Promise<any>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => x : () => any
 >x : any
@@ -1490,14 +1490,14 @@ const pc3 = p.then(() => Promise.reject("1"), () => x);
 const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 >pc4 : Promise<undefined>
 >p.then(() => Promise.reject("1"), () => undefined) : Promise<undefined>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => undefined : () => undefined
 >undefined : undefined
@@ -1505,14 +1505,14 @@ const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 const pc5 = p.then(() => Promise.reject("1"), () => null);
 >pc5 : Promise<null>
 >p.then(() => Promise.reject("1"), () => null) : Promise<null>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => null : () => null
 >null : null
@@ -1520,28 +1520,28 @@ const pc5 = p.then(() => Promise.reject("1"), () => null);
 const pc6 = p.then(() => Promise.reject("1"), () => {});
 >pc6 : Promise<void>
 >p.then(() => Promise.reject("1"), () => {}) : Promise<void>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => {} : () => void
 
 const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 >pc7 : Promise<never>
 >p.then(() => Promise.reject("1"), () => {throw 1}) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => {throw 1} : () => never
 >1 : 1
@@ -1549,38 +1549,38 @@ const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >pc8 : Promise<number>
 >p.then(() => Promise.reject("1"), () => Promise.resolve(1)) : Promise<number>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => Promise.resolve(1) : () => Promise<number>
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >pc9 : Promise<never>
 >p.then(() => Promise.reject("1"), () => Promise.reject(1)) : Promise<never>
->p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >p : Promise<boolean>
->then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1) | null | undefined, onrejected?: ((reason: any) => TResult2) | null | undefined) => Promise<awaited TResult1 | awaited TResult2>
 >() => Promise.reject("1") : () => Promise<never>
 >Promise.reject("1") : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >"1" : "1"
 >() => Promise.reject(1) : () => Promise<never>
 >Promise.reject(1) : Promise<never>
->Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>Promise.reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >Promise : PromiseConstructor
->reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<promised T>; }
+>reject : { (reason: any): Promise<never>; <T>(reason: any): Promise<awaited T>; }
 >1 : 1
 
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.types b/tests/baselines/reference/promiseVoidErrorCallback.types
index 4bebe161bc3..01448dd8e11 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.types
+++ b/tests/baselines/reference/promiseVoidErrorCallback.types
@@ -27,9 +27,9 @@ function f1(): Promise<T1> {
 
     return Promise.resolve({ __t1: "foo_t1" });
 >Promise.resolve({ __t1: "foo_t1" }) : Promise<{ __t1: string; }>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >{ __t1: "foo_t1" } : { __t1: string; }
 >__t1 : string
 >"foo_t1" : "foo_t1"
@@ -54,14 +54,14 @@ function f2(x: T1): T2 {
 var x3 = f1()
 >x3 : Promise<{ __t3: string; }>
 >f1()    .then(f2, (e: Error) => {    throw e;})    .then((x: T2) => {    return { __t3: x.__t2 + "bar" };}) : Promise<{ __t3: string; }>
->f1()    .then(f2, (e: Error) => {    throw e;})    .then : <TResult1 = T2, TResult2 = never>(onfulfilled?: (value: T2) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f1()    .then(f2, (e: Error) => {    throw e;})    .then : <TResult1 = T2, TResult2 = never>(onfulfilled?: (value: T2) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f1()    .then(f2, (e: Error) => {    throw e;}) : Promise<T2>
->f1()    .then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>f1()    .then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f1() : Promise<T1>
 >f1 : () => Promise<T1>
 
     .then(f2, (e: Error) => {
->then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >f2 : (x: T1) => T2
 >(e: Error) => {    throw e;} : (e: Error) => never
 >e : Error
@@ -72,7 +72,7 @@ var x3 = f1()
 
 })
     .then((x: T2) => {
->then : <TResult1 = T2, TResult2 = never>(onfulfilled?: (value: T2) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = T2, TResult2 = never>(onfulfilled?: (value: T2) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >(x: T2) => {    return { __t3: x.__t2 + "bar" };} : (x: T2) => { __t3: string; }
 >x : T2
 >T2 : T2
diff --git a/tests/baselines/reference/promised.symbols b/tests/baselines/reference/promised.symbols
deleted file mode 100644
index 869bc2078a5..00000000000
--- a/tests/baselines/reference/promised.symbols
+++ /dev/null
@@ -1,406 +0,0 @@
-=== tests/cases/conformance/types/promised/promised.ts ===
-// simple
-declare const p0: Promise<number>;
->p0 : Symbol(p0, Decl(promised.ts, 1, 13))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
-
-p0.then(x => x);
->p0.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->p0 : Symbol(p0, Decl(promised.ts, 1, 13))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 2, 8))
->x : Symbol(x, Decl(promised.ts, 2, 8))
-
-declare const p1: Promise<Promise<number>>;
->p1 : Symbol(p1, Decl(promised.ts, 4, 13))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
-
-p1.then(x => x);
->p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->p1 : Symbol(p1, Decl(promised.ts, 4, 13))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 5, 8))
->x : Symbol(x, Decl(promised.ts, 5, 8))
-
-declare const p2: Promise<number | Promise<number>>;
->p2 : Symbol(p2, Decl(promised.ts, 7, 13))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
-
-p2.then(x => x);
->p2.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->p2 : Symbol(p2, Decl(promised.ts, 7, 13))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 8, 8))
->x : Symbol(x, Decl(promised.ts, 8, 8))
-
-// generics
-declare const f: boolean;
->f : Symbol(f, Decl(promised.ts, 11, 13))
-
-declare function makePromise<T>(x: T): Promise<T>;
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->T : Symbol(T, Decl(promised.ts, 12, 29))
->x : Symbol(x, Decl(promised.ts, 12, 32))
->T : Symbol(T, Decl(promised.ts, 12, 29))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->T : Symbol(T, Decl(promised.ts, 12, 29))
-
-makePromise(1).then(x => x);
->makePromise(1).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 13, 20))
->x : Symbol(x, Decl(promised.ts, 13, 20))
-
-makePromise("a").then(x => x);
->makePromise("a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 14, 22))
->x : Symbol(x, Decl(promised.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(promised.ts, 11, 25))
->a : Symbol(a, Decl(promised.ts, 15, 13))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 15, 27))
->x : Symbol(x, Decl(promised.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(promised.ts, 11, 25))
->f : Symbol(f, Decl(promised.ts, 11, 13))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 16, 30))
->x : Symbol(x, Decl(promised.ts, 16, 30))
-
-function f0<U>(u: U) {
->f0 : Symbol(f0, Decl(promised.ts, 16, 38))
->U : Symbol(U, Decl(promised.ts, 18, 12))
->u : Symbol(u, Decl(promised.ts, 18, 15))
->U : Symbol(U, Decl(promised.ts, 18, 12))
-
-    return makePromise(u).then(x => x);
->makePromise(u).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->u : Symbol(u, Decl(promised.ts, 18, 15))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 19, 31))
->x : Symbol(x, Decl(promised.ts, 19, 31))
-}
-f0(1).then(x => x);
->f0(1).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->f0 : Symbol(f0, Decl(promised.ts, 16, 38))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 21, 11))
->x : Symbol(x, Decl(promised.ts, 21, 11))
-
-f0("a").then(x => x);
->f0("a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->f0 : Symbol(f0, Decl(promised.ts, 16, 38))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 22, 13))
->x : Symbol(x, Decl(promised.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(promised.ts, 16, 38))
->f : Symbol(f, Decl(promised.ts, 11, 13))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 23, 21))
->x : Symbol(x, Decl(promised.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(promised.ts, 16, 38))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 24, 24))
->x : Symbol(x, Decl(promised.ts, 24, 24))
-
-function f1<U, V>(u: U, v: V) {
->f1 : Symbol(f1, Decl(promised.ts, 24, 32))
->U : Symbol(U, Decl(promised.ts, 26, 12))
->V : Symbol(V, Decl(promised.ts, 26, 14))
->u : Symbol(u, Decl(promised.ts, 26, 18))
->U : Symbol(U, Decl(promised.ts, 26, 12))
->v : Symbol(v, Decl(promised.ts, 26, 23))
->V : Symbol(V, Decl(promised.ts, 26, 14))
-
-    return makePromise(u).then(x => {
->makePromise(u).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->u : Symbol(u, Decl(promised.ts, 26, 18))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 27, 31))
-
-        if (f) return x;
->f : Symbol(f, Decl(promised.ts, 11, 13))
->x : Symbol(x, Decl(promised.ts, 27, 31))
-
-        return makePromise(v).then(x => x);
->makePromise(v).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->v : Symbol(v, Decl(promised.ts, 26, 23))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 29, 35))
->x : Symbol(x, Decl(promised.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(promised.ts, 24, 32))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 32, 16))
->x : Symbol(x, Decl(promised.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(promised.ts, 24, 32))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 33, 42))
->x : Symbol(x, Decl(promised.ts, 33, 42))
-
-function f2<U>(u: U) {
->f2 : Symbol(f2, Decl(promised.ts, 33, 50))
->U : Symbol(U, Decl(promised.ts, 35, 12))
->u : Symbol(u, Decl(promised.ts, 35, 15))
->U : Symbol(U, Decl(promised.ts, 35, 12))
-
-    return makePromise(u).then(x => {
->makePromise(u).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->u : Symbol(u, Decl(promised.ts, 35, 15))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 36, 31))
-
-        if (f) return x;
->f : Symbol(f, Decl(promised.ts, 11, 13))
->x : Symbol(x, Decl(promised.ts, 36, 31))
-
-        return Promise.reject("b");
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
-
-    });
-}
-f2(1).then(x => x);
->f2(1).then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->f2 : Symbol(f2, Decl(promised.ts, 33, 50))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 41, 11))
->x : Symbol(x, Decl(promised.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(promised.ts, 33, 50))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 42, 24))
->x : Symbol(x, Decl(promised.ts, 42, 24))
-
-function f3<U, V>(u: U, v: V) {
->f3 : Symbol(f3, Decl(promised.ts, 42, 32))
->U : Symbol(U, Decl(promised.ts, 44, 12))
->V : Symbol(V, Decl(promised.ts, 44, 14))
->u : Symbol(u, Decl(promised.ts, 44, 18))
->U : Symbol(U, Decl(promised.ts, 44, 12))
->v : Symbol(v, Decl(promised.ts, 44, 23))
->V : Symbol(V, Decl(promised.ts, 44, 14))
-
-    return makePromise(u).catch(x => v);
->makePromise(u).catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->u : Symbol(u, Decl(promised.ts, 44, 18))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 45, 32))
->v : Symbol(v, Decl(promised.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(promised.ts, 42, 32))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 47, 16))
->x : Symbol(x, Decl(promised.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(promised.ts, 42, 32))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 48, 42))
->x : Symbol(x, Decl(promised.ts, 48, 42))
-
-function f4<U, V>(u: U, v: V) {
->f4 : Symbol(f4, Decl(promised.ts, 48, 50))
->U : Symbol(U, Decl(promised.ts, 50, 12))
->V : Symbol(V, Decl(promised.ts, 50, 14))
->u : Symbol(u, Decl(promised.ts, 50, 18))
->U : Symbol(U, Decl(promised.ts, 50, 12))
->v : Symbol(v, Decl(promised.ts, 50, 23))
->V : Symbol(V, Decl(promised.ts, 50, 14))
-
-    return makePromise(u).catch(x => {
->makePromise(u).catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->u : Symbol(u, Decl(promised.ts, 50, 18))
->catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 51, 32))
-
-        if (f) return v;
->f : Symbol(f, Decl(promised.ts, 11, 13))
->v : Symbol(v, Decl(promised.ts, 50, 23))
-
-        return Promise.reject("b");
->Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
-
-    });
-}
-f4(1, "a").then(x => x);
->f4(1, "a").then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->f4 : Symbol(f4, Decl(promised.ts, 48, 50))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 56, 16))
->x : Symbol(x, Decl(promised.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(promised.ts, 48, 50))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 57, 42))
->x : Symbol(x, Decl(promised.ts, 57, 42))
-
-async function f5<U>(u: Promise<U>) {
->f5 : Symbol(f5, Decl(promised.ts, 57, 50))
->U : Symbol(U, Decl(promised.ts, 59, 18))
->u : Symbol(u, Decl(promised.ts, 59, 21))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->U : Symbol(U, Decl(promised.ts, 59, 18))
-
-    return await u;
->u : Symbol(u, Decl(promised.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(promised.ts, 57, 50))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 62, 24))
->x : Symbol(x, Decl(promised.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(promised.ts, 57, 50))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->makePromise : Symbol(makePromise, Decl(promised.ts, 11, 25))
->then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
->x : Symbol(x, Decl(promised.ts, 63, 37))
->x : Symbol(x, Decl(promised.ts, 63, 37))
-
-async function f6<U>(u: Promise<Promise<U>>) {
->f6 : Symbol(f6, Decl(promised.ts, 63, 45))
->U : Symbol(U, Decl(promised.ts, 65, 18))
->u : Symbol(u, Decl(promised.ts, 65, 21))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->U : Symbol(U, Decl(promised.ts, 65, 18))
-
-    return await u;
->u : Symbol(u, Decl(promised.ts, 65, 21))
-}
-
-// assignability
-let v0: number;
->v0 : Symbol(v0, Decl(promised.ts, 70, 3))
-
-let v1: promised number;
->v1 : Symbol(v1, Decl(promised.ts, 71, 3))
-
-let v2: promised Promise<number>;
->v2 : Symbol(v2, Decl(promised.ts, 72, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
-
-v0 = v1;
->v0 : Symbol(v0, Decl(promised.ts, 70, 3))
->v1 : Symbol(v1, Decl(promised.ts, 71, 3))
-
-v0 = v2;
->v0 : Symbol(v0, Decl(promised.ts, 70, 3))
->v2 : Symbol(v2, Decl(promised.ts, 72, 3))
-
-v1 = v0;
->v1 : Symbol(v1, Decl(promised.ts, 71, 3))
->v0 : Symbol(v0, Decl(promised.ts, 70, 3))
-
-v1 = v2;
->v1 : Symbol(v1, Decl(promised.ts, 71, 3))
->v2 : Symbol(v2, Decl(promised.ts, 72, 3))
-
-v2 = v0;
->v2 : Symbol(v2, Decl(promised.ts, 72, 3))
->v0 : Symbol(v0, Decl(promised.ts, 70, 3))
-
-v2 = v1;
->v2 : Symbol(v2, Decl(promised.ts, 72, 3))
->v1 : Symbol(v1, Decl(promised.ts, 71, 3))
-
-function f7<U>() {
->f7 : Symbol(f7, Decl(promised.ts, 78, 8))
->U : Symbol(U, Decl(promised.ts, 80, 12))
-
-    let v0: promised U;
->v0 : Symbol(v0, Decl(promised.ts, 81, 7))
->U : Symbol(U, Decl(promised.ts, 80, 12))
-
-    let v1: promised Promise<U>;
->v1 : Symbol(v1, Decl(promised.ts, 82, 7))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->U : Symbol(U, Decl(promised.ts, 80, 12))
-
-    v0 = v1;
->v0 : Symbol(v0, Decl(promised.ts, 81, 7))
->v1 : Symbol(v1, Decl(promised.ts, 82, 7))
-
-    v1 = v0;
->v1 : Symbol(v1, Decl(promised.ts, 82, 7))
->v0 : Symbol(v0, Decl(promised.ts, 81, 7))
-}
-
-async function f8<U>() {
->f8 : Symbol(f8, Decl(promised.ts, 85, 1))
->U : Symbol(U, Decl(promised.ts, 87, 18))
-
-    let pu: Promise<U>;
->pu : Symbol(pu, Decl(promised.ts, 88, 7))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->U : Symbol(U, Decl(promised.ts, 87, 18))
-
-    let v0: promised U;
->v0 : Symbol(v0, Decl(promised.ts, 89, 7))
->U : Symbol(U, Decl(promised.ts, 87, 18))
-
-    let v1: promised Promise<U>;
->v1 : Symbol(v1, Decl(promised.ts, 90, 7))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->U : Symbol(U, Decl(promised.ts, 87, 18))
-
-    v0 = await pu;
->v0 : Symbol(v0, Decl(promised.ts, 89, 7))
->pu : Symbol(pu, Decl(promised.ts, 88, 7))
-
-    v1 = await pu;
->v1 : Symbol(v1, Decl(promised.ts, 90, 7))
->pu : Symbol(pu, Decl(promised.ts, 88, 7))
-}
diff --git a/tests/baselines/reference/promises.types b/tests/baselines/reference/promises.types
index 0e7386197c4..b2d200444b5 100644
--- a/tests/baselines/reference/promises.types
+++ b/tests/baselines/reference/promises.types
@@ -4,7 +4,7 @@ interface Promise<T> {
 >T : T
 
     then<U>(success?: (value: T) => U): Promise<U>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: promised T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
 >U : U
 >success : (value: T) => U
 >value : T
@@ -14,7 +14,7 @@ interface Promise<T> {
 >U : U
 
     then<U>(success?: (value: T) => Promise<U>): Promise<U>;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: promised T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
 >U : U
 >success : (value: T) => Promise<U>
 >value : T
diff --git a/tests/baselines/reference/specializationError.types b/tests/baselines/reference/specializationError.types
index 2992c642e90..30b217bcd8d 100644
--- a/tests/baselines/reference/specializationError.types
+++ b/tests/baselines/reference/specializationError.types
@@ -4,7 +4,7 @@ interface Promise<T> {
 >T : T
 
     then<U>(value: T): void;
->then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: promised T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<promised TResult1 | promised TResult2>; <U>(value: T): void; }
+>then : { <TResult1 = T, TResult2 = never>(onfulfilled?: (value: awaited T) => TResult1, onrejected?: (reason: any) => TResult2): Promise<awaited TResult1 | awaited TResult2>; <U>(value: T): void; }
 >U : U
 >value : T
 >T : T
diff --git a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types
index 6577a9b2df6..fbd0f6ff995 100644
--- a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types
+++ b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types
@@ -9,10 +9,10 @@ export = packageExport;
 === tests/cases/compiler/index.ts ===
 import("package").then(({default: foo}) => foo(42));
 >import("package").then(({default: foo}) => foo(42)) : Promise<string>
->import("package").then : <TResult1 = ((x: number) => string) & { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: ((x: number) => string) & { default: (x: number) => string; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>import("package").then : <TResult1 = ((x: number) => string) & { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: ((x: number) => string) & { default: (x: number) => string; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >import("package") : Promise<((x: number) => string) & { default: (x: number) => string; }>
 >"package" : "package"
->then : <TResult1 = ((x: number) => string) & { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: ((x: number) => string) & { default: (x: number) => string; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<promised TResult1 | promised TResult2>
+>then : <TResult1 = ((x: number) => string) & { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: ((x: number) => string) & { default: (x: number) => string; }) => TResult1, onrejected?: (reason: any) => TResult2) => Promise<awaited TResult1 | awaited TResult2>
 >({default: foo}) => foo(42) : ({ default: foo }: ((x: number) => string) & { default: (x: number) => string; }) => string
 >default : any
 >foo : (x: number) => string
diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.types b/tests/baselines/reference/transformNestedGeneratorsWithTry.types
index 58075208cbb..3fcacaacafb 100644
--- a/tests/baselines/reference/transformNestedGeneratorsWithTry.types
+++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.types
@@ -18,9 +18,9 @@ async function a(): Bluebird<void> {
         await Bluebird.resolve(); // -- remove this and it compiles
 >await Bluebird.resolve() : void
 >Bluebird.resolve() : Promise<void>
->Bluebird.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Bluebird.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Bluebird : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 
       } catch (error) { }
 >error : any
diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.1.types b/tests/baselines/reference/types.asyncGenerators.esnext.1.types
index 86eb9db80ab..c7d5e2d0333 100644
--- a/tests/baselines/reference/types.asyncGenerators.esnext.1.types
+++ b/tests/baselines/reference/types.asyncGenerators.esnext.1.types
@@ -21,9 +21,9 @@ async function * inferReturnType4() {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * inferReturnType5() {
@@ -36,9 +36,9 @@ async function * inferReturnType5() {
     yield Promise.resolve(2);
 >yield Promise.resolve(2) : any
 >Promise.resolve(2) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >2 : 2
 }
 async function * inferReturnType6() {
@@ -57,9 +57,9 @@ async function * inferReturnType7() {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * inferReturnType8() {
@@ -91,9 +91,9 @@ const assignability2: () => AsyncIterableIterator<number> = async function * ()
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -118,9 +118,9 @@ const assignability4: () => AsyncIterableIterator<number> = async function * ()
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -156,9 +156,9 @@ const assignability7: () => AsyncIterable<number> = async function * () {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -183,9 +183,9 @@ const assignability9: () => AsyncIterable<number> = async function * () {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -221,9 +221,9 @@ const assignability12: () => AsyncIterator<number> = async function * () {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -248,9 +248,9 @@ const assignability14: () => AsyncIterator<number> = async function * () {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 
 };
@@ -283,9 +283,9 @@ async function * explicitReturnType2(): AsyncIterableIterator<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType3(): AsyncIterableIterator<number> {
@@ -306,9 +306,9 @@ async function * explicitReturnType4(): AsyncIterableIterator<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType5(): AsyncIterableIterator<number> {
@@ -338,9 +338,9 @@ async function * explicitReturnType7(): AsyncIterable<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType8(): AsyncIterable<number> {
@@ -361,9 +361,9 @@ async function * explicitReturnType9(): AsyncIterable<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType10(): AsyncIterable<number> {
@@ -393,9 +393,9 @@ async function * explicitReturnType12(): AsyncIterator<number> {
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType13(): AsyncIterator<number> {
@@ -416,9 +416,9 @@ async function * explicitReturnType14(): AsyncIterator<number> {
 >yield* [Promise.resolve(1)] : any
 >[Promise.resolve(1)] : Promise<number>[]
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
 async function * explicitReturnType15(): AsyncIterator<number> {
@@ -455,8 +455,8 @@ async function * awaitedType2() {
 >x : number
 >await Promise.resolve(1) : number
 >Promise.resolve(1) : Promise<number>
->Promise.resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>Promise.resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >Promise : PromiseConstructor
->resolve : { <T>(value: T): Promise<promised T>; (): Promise<void>; }
+>resolve : { <T>(value: T): Promise<awaited T>; (): Promise<void>; }
 >1 : 1
 }
diff --git a/tests/cases/conformance/types/promised/promised.ts b/tests/cases/conformance/types/awaited/awaited.ts
similarity index 87%
rename from tests/cases/conformance/types/promised/promised.ts
rename to tests/cases/conformance/types/awaited/awaited.ts
index 2874f2b9fc0..91564b4945c 100644
--- a/tests/cases/conformance/types/promised/promised.ts
+++ b/tests/cases/conformance/types/awaited/awaited.ts
@@ -71,8 +71,8 @@ async function f6<U>(u: Promise<Promise<U>>) {
 
 // assignability
 let v0: number;
-let v1: promised number;
-let v2: promised Promise<number>;
+let v1: awaited number;
+let v2: awaited Promise<number>;
 v0 = v1;
 v0 = v2;
 v1 = v0;
@@ -81,16 +81,16 @@ v2 = v0;
 v2 = v1;
 
 function f7<U>() {
-    let v0: promised U;
-    let v1: promised Promise<U>;
+    let v0: awaited U;
+    let v1: awaited Promise<U>;
     v0 = v1;
     v1 = v0;
 }
 
 async function f8<U>() {
     let pu: Promise<U>;
-    let v0: promised U;
-    let v1: promised Promise<U>;
+    let v0: awaited U;
+    let v1: awaited Promise<U>;
     v0 = await pu;
     v1 = await pu;
 }
\ No newline at end of file