Skip to content

Commit 25d813f

Browse files
jablkojablko
committed
Defer generic awaited type
1 parent d0c961e commit 25d813f

23 files changed

+264
-228
lines changed

‎src/compiler/checker.ts

+18-90
Original file line numberDiff line numberDiff line change
@@ -842,6 +842,7 @@ namespace ts {
842842
let deferredGlobalESSymbolConstructorSymbol: Symbol | undefined;
843843
let deferredGlobalESSymbolType: ObjectType;
844844
let deferredGlobalTypedPropertyDescriptorType: GenericType;
845+
let deferredGlobalAwaitedSymbol: Symbol | undefined;
845846
let deferredGlobalPromiseType: GenericType;
846847
let deferredGlobalPromiseLikeType: GenericType;
847848
let deferredGlobalPromiseConstructorSymbol: Symbol | undefined;
@@ -896,7 +897,6 @@ namespace ts {
896897
const potentialThisCollisions: Node[] = [];
897898
const potentialNewTargetCollisions: Node[] = [];
898899
const potentialWeakMapCollisions: Node[] = [];
899-
const awaitedTypeStack: number[] = [];
900900

901901
const diagnostics = createDiagnosticCollection();
902902
const suggestionDiagnostics = createDiagnosticCollection();
@@ -11455,6 +11455,10 @@ namespace ts {
1145511455
return deferredGlobalESSymbolType || (deferredGlobalESSymbolType = getGlobalType("Symbol" as __String, /*arity*/ 0, reportErrors)) || emptyObjectType;
1145611456
}
1145711457

11458+
function getGlobalAwaitedSymbol(reportErrors: boolean) {
11459+
return deferredGlobalAwaitedSymbol || (deferredGlobalAwaitedSymbol = getGlobalTypeSymbol("Awaited" as __String, reportErrors));
11460+
}
11461+
1145811462
function getGlobalPromiseType(reportErrors: boolean) {
1145911463
return deferredGlobalPromiseType || (deferredGlobalPromiseType = getGlobalType("Promise" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType;
1146011464
}
@@ -26272,8 +26276,6 @@ namespace ts {
2627226276
// creates a `Promise<T>` type where `T` is the promisedType argument
2627326277
const globalPromiseType = getGlobalPromiseType(/*reportErrors*/ true);
2627426278
if (globalPromiseType !== emptyGenericType) {
26275-
// if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type
26276-
promisedType = getAwaitedType(promisedType) || unknownType;
2627726279
return createTypeReference(globalPromiseType, [promisedType]);
2627826280
}
2627926281

@@ -26284,8 +26286,6 @@ namespace ts {
2628426286
// creates a `PromiseLike<T>` type where `T` is the promisedType argument
2628526287
const globalPromiseLikeType = getGlobalPromiseLikeType(/*reportErrors*/ true);
2628626288
if (globalPromiseLikeType !== emptyGenericType) {
26287-
// if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type
26288-
promisedType = getAwaitedType(promisedType) || unknownType;
2628926289
return createTypeReference(globalPromiseLikeType, [promisedType]);
2629026290
}
2629126291

@@ -29746,98 +29746,26 @@ namespace ts {
2974629746
return typeAsAwaitable.awaitedTypeOfType = type;
2974729747
}
2974829748

29749-
if (type.flags & TypeFlags.Union) {
29750-
let types: Type[] | undefined;
29751-
for (const constituentType of (<UnionType>type).types) {
29752-
types = append<Type>(types, getAwaitedType(constituentType, errorNode, diagnosticMessage, arg0));
29753-
}
29754-
29755-
if (!types) {
29756-
return undefined;
29757-
}
29758-
29759-
return typeAsAwaitable.awaitedTypeOfType = getUnionType(types);
29749+
const symbol = getGlobalAwaitedSymbol(/*reportErrors*/ false);
29750+
if (!symbol) {
29751+
return typeAsAwaitable.awaitedTypeOfType = type;
2976029752
}
2976129753

29762-
const promisedType = getPromisedTypeOfPromise(type);
29763-
if (promisedType) {
29764-
if (type.id === promisedType.id || awaitedTypeStack.indexOf(promisedType.id) >= 0) {
29765-
// Verify that we don't have a bad actor in the form of a promise whose
29766-
// promised type is the same as the promise type, or a mutually recursive
29767-
// promise. If so, we return undefined as we cannot guess the shape. If this
29768-
// were the actual case in the JavaScript, this Promise would never resolve.
29769-
//
29770-
// An example of a bad actor with a singly-recursive promise type might
29771-
// be:
29772-
//
29773-
// interface BadPromise {
29774-
// then(
29775-
// onfulfilled: (value: BadPromise) => any,
29776-
// onrejected: (error: any) => any): BadPromise;
29777-
// }
29778-
// The above interface will pass the PromiseLike check, and return a
29779-
// promised type of `BadPromise`. Since this is a self reference, we
29780-
// don't want to keep recursing ad infinitum.
29781-
//
29782-
// An example of a bad actor in the form of a mutually-recursive
29783-
// promise type might be:
29784-
//
29785-
// interface BadPromiseA {
29786-
// then(
29787-
// onfulfilled: (value: BadPromiseB) => any,
29788-
// onrejected: (error: any) => any): BadPromiseB;
29789-
// }
29790-
//
29791-
// interface BadPromiseB {
29792-
// then(
29793-
// onfulfilled: (value: BadPromiseA) => any,
29794-
// onrejected: (error: any) => any): BadPromiseA;
29795-
// }
29796-
//
29797-
if (errorNode) {
29798-
error(errorNode, Diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method);
29799-
}
29800-
return undefined;
29801-
}
29802-
29803-
// Keep track of the type we're about to unwrap to avoid bad recursive promise types.
29804-
// See the comments above for more information.
29805-
awaitedTypeStack.push(type.id);
29806-
const awaitedType = getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0);
29807-
awaitedTypeStack.pop();
29808-
29809-
if (!awaitedType) {
29810-
return undefined;
29811-
}
29754+
if (type.aliasSymbol === symbol) {
29755+
return typeAsAwaitable.awaitedTypeOfType = type;
29756+
}
2981229757

29813-
return typeAsAwaitable.awaitedTypeOfType = awaitedType;
29758+
const result = getTypeAliasInstantiation(symbol, [type]);
29759+
if (result !== unknownType || type === unknownType || getPromisedTypeOfPromise(type) === unknownType) {
29760+
return typeAsAwaitable.awaitedTypeOfType = result;
2981429761
}
2981529762

29816-
// The type was not a promise, so it could not be unwrapped any further.
29817-
// As long as the type does not have a callable "then" property, it is
29818-
// safe to return the type; otherwise, an error will be reported in
29819-
// the call to getNonThenableType and we will return undefined.
29820-
//
29821-
// An example of a non-promise "thenable" might be:
29822-
//
29823-
// await { then(): void {} }
29824-
//
29825-
// The "thenable" does not match the minimal definition for a promise. When
29826-
// a Promise/A+-compatible or ES6 promise tries to adopt this value, the promise
29827-
// will never settle. We treat this as an error to help flag an early indicator
29828-
// of a runtime problem. If the user wants to return this value from an async
29829-
// function, they would need to wrap it in some other value. If they want it to
29830-
// be treated as a promise, they can cast to <any>.
29831-
const thenFunction = getTypeOfPropertyOfType(type, "then" as __String);
29832-
if (thenFunction && getSignaturesOfType(thenFunction, SignatureKind.Call).length > 0) {
29833-
if (errorNode) {
29834-
if (!diagnosticMessage) return Debug.fail();
29835-
error(errorNode, diagnosticMessage, arg0);
29836-
}
29837-
return undefined;
29763+
if (errorNode) {
29764+
if (!diagnosticMessage) return Debug.fail();
29765+
error(errorNode, diagnosticMessage, arg0);
2983829766
}
2983929767

29840-
return typeAsAwaitable.awaitedTypeOfType = type;
29768+
return undefined;
2984129769
}
2984229770

2984329771
/**

‎src/harness/fourslashInterfaceImpl.ts

+1
Original file line numberDiff line numberDiff line change
@@ -961,6 +961,7 @@ namespace FourSlashInterface {
961961
typeEntry("PropertyDecorator"),
962962
typeEntry("MethodDecorator"),
963963
typeEntry("ParameterDecorator"),
964+
typeEntry("Awaited"),
964965
typeEntry("PromiseConstructorLike"),
965966
interfaceEntry("PromiseLike"),
966967
interfaceEntry("Promise"),

‎src/lib/es5.d.ts

+5
Original file line numberDiff line numberDiff line change
@@ -1378,6 +1378,11 @@ declare type PropertyDecorator = (target: Object, propertyKey: string | symbol)
13781378
declare type MethodDecorator = <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
13791379
declare type ParameterDecorator = (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
13801380

1381+
// The undefined case is for strictNullChecks false, in which case
1382+
// undefined extends PromiseLike<infer U> is true, which would otherwise
1383+
// make Awaited<undefined> -> unknown.
1384+
type Awaited<T> = T extends undefined ? T : T extends PromiseLike<infer U> ? U : T extends { then: Function } ? unknown : T;
1385+
13811386
declare type PromiseConstructorLike = new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) => PromiseLike<T>;
13821387

13831388
interface PromiseLike<T> {

‎tests/baselines/reference/asyncArrowFunctionCapturesThis_es2017.types

+3-3
Original file line numberDiff line numberDiff line change
@@ -6,9 +6,9 @@ class C {
66
>method : () => void
77

88
var fn = async () => await this;
9-
>fn : () => Promise<this>
10-
>async () => await this : () => Promise<this>
11-
>await this : this
9+
>fn : () => Promise<Awaited<this>>
10+
>async () => await this : () => Promise<Awaited<this>>
11+
>await this : Awaited<this>
1212
>this : this
1313
}
1414
}

‎tests/baselines/reference/asyncArrowFunctionCapturesThis_es5.types

+3-3
Original file line numberDiff line numberDiff line change
@@ -6,9 +6,9 @@ class C {
66
>method : () => void
77

88
var fn = async () => await this;
9-
>fn : () => Promise<this>
10-
>async () => await this : () => Promise<this>
11-
>await this : this
9+
>fn : () => Promise<Awaited<this>>
10+
>async () => await this : () => Promise<Awaited<this>>
11+
>await this : Awaited<this>
1212
>this : this
1313
}
1414
}

‎tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types

+3-3
Original file line numberDiff line numberDiff line change
@@ -6,9 +6,9 @@ class C {
66
>method : () => void
77

88
var fn = async () => await this;
9-
>fn : () => Promise<this>
10-
>async () => await this : () => Promise<this>
11-
>await this : this
9+
>fn : () => Promise<Awaited<this>>
10+
>async () => await this : () => Promise<Awaited<this>>
11+
>await this : Awaited<this>
1212
>this : this
1313
}
1414
}

‎tests/baselines/reference/asyncFunctionReturnType.js

+3-2
Original file line numberDiff line numberDiff line change
@@ -63,7 +63,7 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
6363
return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
6464
}
6565

66-
async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
66+
async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<Awaited<TObj[K]>> {
6767
return obj[key];
6868
}
6969

@@ -73,7 +73,8 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
7373

7474
async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
7575
return Promise.resolve<TObj[K]>(obj[key]);
76-
}
76+
}
77+
7778

7879
//// [asyncFunctionReturnType.js]
7980
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {

‎tests/baselines/reference/asyncFunctionReturnType.symbols

+3-1
Original file line numberDiff line numberDiff line change
@@ -221,7 +221,7 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
221221
>anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
222222
}
223223

224-
async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
224+
async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<Awaited<TObj[K]>> {
225225
>fGenericIndexedTypeForKProp : Symbol(fGenericIndexedTypeForKProp, Decl(asyncFunctionReturnType.ts, 62, 1))
226226
>TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 64, 43))
227227
>Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
@@ -232,6 +232,7 @@ async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TOb
232232
>key : Symbol(key, Decl(asyncFunctionReturnType.ts, 64, 93))
233233
>K : Symbol(K, Decl(asyncFunctionReturnType.ts, 64, 60))
234234
>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
235+
>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --))
235236
>TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 64, 43))
236237
>K : Symbol(K, Decl(asyncFunctionReturnType.ts, 64, 60))
237238

@@ -285,3 +286,4 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
285286
>obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 72, 100))
286287
>key : Symbol(key, Decl(asyncFunctionReturnType.ts, 72, 110))
287288
}
289+

‎tests/baselines/reference/asyncFunctionReturnType.types

+3-2
Original file line numberDiff line numberDiff line change
@@ -180,8 +180,8 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
180180
>anyProp : any
181181
}
182182

183-
async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<TObj[K]> {
184-
>fGenericIndexedTypeForKProp : <TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K) => Promise<TObj[K]>
183+
async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K): Promise<Awaited<TObj[K]>> {
184+
>fGenericIndexedTypeForKProp : <TObj extends Obj, K extends keyof TObj>(obj: TObj, key: K) => Promise<Awaited<TObj[K]>>
185185
>obj : TObj
186186
>key : K
187187

@@ -220,3 +220,4 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
220220
>obj : TObj
221221
>key : K
222222
}
223+

‎tests/baselines/reference/compareTypeParameterConstrainedByLiteralToLiteral.errors.txt

+1
Original file line numberDiff line numberDiff line change
@@ -9,5 +9,6 @@ tests/cases/compiler/compareTypeParameterConstrainedByLiteralToLiteral.ts(5,5):
99
t === "x"; // Should be error
1010
~~~~~~~~~
1111
!!! error TS2367: This condition will always return 'false' since the types 'T' and '"x"' have no overlap.
12+
!!! related TS2773 tests/cases/compiler/compareTypeParameterConstrainedByLiteralToLiteral.ts:5:5: Did you forget to use 'await'?
1213
}
1314

0 commit comments

Comments
 (0)