@@ -1181,8 +1181,9 @@ interface IterationTypesResolver {
1181
1181
getGlobalIteratorType: (reportErrors: boolean) => GenericType;
1182
1182
getGlobalIterableType: (reportErrors: boolean) => GenericType;
1183
1183
getGlobalIterableIteratorType: (reportErrors: boolean) => GenericType;
1184
- getGlobalBuiltinIteratorType : (reportErrors: boolean) => GenericType;
1184
+ getGlobalIteratorObjectType : (reportErrors: boolean) => GenericType;
1185
1185
getGlobalGeneratorType: (reportErrors: boolean) => GenericType;
1186
+ getGlobalBuiltinIteratorTypes: () => readonly GenericType[];
1186
1187
resolveIterationType: (type: Type, errorNode: Node | undefined) => Type | undefined;
1187
1188
mustHaveANextMethodDiagnostic: DiagnosticMessage;
1188
1189
mustBeAMethodDiagnostic: DiagnosticMessage;
@@ -2167,8 +2168,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
2167
2168
getGlobalIteratorType: getGlobalAsyncIteratorType,
2168
2169
getGlobalIterableType: getGlobalAsyncIterableType,
2169
2170
getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType,
2170
- getGlobalBuiltinIteratorType: getGlobalBuiltinAsyncIteratorType ,
2171
+ getGlobalIteratorObjectType: getGlobalAsyncIteratorObjectType ,
2171
2172
getGlobalGeneratorType: getGlobalAsyncGeneratorType,
2173
+ getGlobalBuiltinIteratorTypes: getGlobalBuiltinAsyncIteratorTypes,
2172
2174
resolveIterationType: (type, errorNode) => getAwaitedType(type, errorNode, Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member),
2173
2175
mustHaveANextMethodDiagnostic: Diagnostics.An_async_iterator_must_have_a_next_method,
2174
2176
mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method,
@@ -2182,8 +2184,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
2182
2184
getGlobalIteratorType,
2183
2185
getGlobalIterableType,
2184
2186
getGlobalIterableIteratorType,
2185
- getGlobalBuiltinIteratorType ,
2187
+ getGlobalIteratorObjectType ,
2186
2188
getGlobalGeneratorType,
2189
+ getGlobalBuiltinIteratorTypes,
2187
2190
resolveIterationType: (type, _errorNode) => type,
2188
2191
mustHaveANextMethodDiagnostic: Diagnostics.An_iterator_must_have_a_next_method,
2189
2192
mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_iterator_must_be_a_method,
@@ -2244,14 +2247,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
2244
2247
var deferredGlobalIterableType: GenericType | undefined;
2245
2248
var deferredGlobalIteratorType: GenericType | undefined;
2246
2249
var deferredGlobalIterableIteratorType: GenericType | undefined;
2247
- var deferredGlobalBuiltinIteratorType : GenericType | undefined;
2250
+ var deferredGlobalIteratorObjectType : GenericType | undefined;
2248
2251
var deferredGlobalGeneratorType: GenericType | undefined;
2249
2252
var deferredGlobalIteratorYieldResultType: GenericType | undefined;
2250
2253
var deferredGlobalIteratorReturnResultType: GenericType | undefined;
2251
2254
var deferredGlobalAsyncIterableType: GenericType | undefined;
2252
2255
var deferredGlobalAsyncIteratorType: GenericType | undefined;
2253
2256
var deferredGlobalAsyncIterableIteratorType: GenericType | undefined;
2254
- var deferredGlobalBuiltinAsyncIteratorType: GenericType | undefined;
2257
+ var deferredGlobalBuiltinIteratorTypes: readonly GenericType[] | undefined;
2258
+ var deferredGlobalBuiltinAsyncIteratorTypes: readonly GenericType[] | undefined;
2259
+ var deferredGlobalAsyncIteratorObjectType: GenericType | undefined;
2255
2260
var deferredGlobalAsyncGeneratorType: GenericType | undefined;
2256
2261
var deferredGlobalTemplateStringsArrayType: ObjectType | undefined;
2257
2262
var deferredGlobalImportMetaType: ObjectType;
@@ -12488,6 +12493,18 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
12488
12493
return removeMissingType(getTypeOfSymbol(symbol), !!(symbol.flags & SymbolFlags.Optional));
12489
12494
}
12490
12495
12496
+ function isReferenceToSomeType(type: Type, targets: readonly Type[]) {
12497
+ if (type === undefined || (getObjectFlags(type) & ObjectFlags.Reference) === 0) {
12498
+ return false;
12499
+ }
12500
+ for (const target of targets) {
12501
+ if ((type as TypeReference).target === target) {
12502
+ return true;
12503
+ }
12504
+ }
12505
+ return false;
12506
+ }
12507
+
12491
12508
function isReferenceToType(type: Type, target: Type) {
12492
12509
return type !== undefined
12493
12510
&& target !== undefined
@@ -13001,7 +13018,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
13001
13018
links.instantiations.set(getTypeListId(typeParameters), type);
13002
13019
}
13003
13020
if (type === intrinsicMarkerType && symbol.escapedName === "BuiltinIteratorReturn") {
13004
- type = strictBuiltinIteratorReturn ? undefinedType : anyType ;
13021
+ type = getBuiltinIteratorReturnType() ;
13005
13022
}
13006
13023
}
13007
13024
else {
@@ -16868,6 +16885,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
16868
16885
return symbol || reportErrors ? getTypeOfGlobalSymbol(symbol, arity) : undefined;
16869
16886
}
16870
16887
16888
+ function getGlobalBuiltinTypes(typeNames: readonly string[], arity: 0): ObjectType[];
16889
+ function getGlobalBuiltinTypes(typeNames: readonly string[], arity: number): GenericType[];
16890
+ function getGlobalBuiltinTypes(typeNames: readonly string[], arity: number) {
16891
+ let types: Type[] | undefined;
16892
+ for (const typeName of typeNames) {
16893
+ types = append(types, getGlobalType(typeName as __String, arity, /*reportErrors*/ false));
16894
+ }
16895
+ return types ?? emptyArray;
16896
+ }
16897
+
16871
16898
function getGlobalTypedPropertyDescriptorType() {
16872
16899
// We always report an error, so store a result in the event we could not resolve the symbol to prevent reporting it multiple times
16873
16900
return deferredGlobalTypedPropertyDescriptorType ||= getGlobalType("TypedPropertyDescriptor" as __String, /*arity*/ 1, /*reportErrors*/ true) || emptyGenericType;
@@ -16949,8 +16976,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
16949
16976
return (deferredGlobalAsyncIterableIteratorType ||= getGlobalType("AsyncIterableIterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
16950
16977
}
16951
16978
16952
- function getGlobalBuiltinAsyncIteratorType(reportErrors: boolean) {
16953
- return (deferredGlobalBuiltinAsyncIteratorType ||= getGlobalType("BuiltinAsyncIterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
16979
+ function getGlobalBuiltinAsyncIteratorTypes() {
16980
+ // NOTE: This list does not include all built-in async iterator types, only those that are likely to be encountered frequently.
16981
+ return deferredGlobalBuiltinAsyncIteratorTypes ??= getGlobalBuiltinTypes(["ReadableStreamAsyncIterator"], 1);
16982
+ }
16983
+
16984
+ function getGlobalAsyncIteratorObjectType(reportErrors: boolean) {
16985
+ return (deferredGlobalAsyncIteratorObjectType ||= getGlobalType("AsyncIteratorObject" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
16954
16986
}
16955
16987
16956
16988
function getGlobalAsyncGeneratorType(reportErrors: boolean) {
@@ -16969,8 +17001,17 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
16969
17001
return (deferredGlobalIterableIteratorType ||= getGlobalType("IterableIterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
16970
17002
}
16971
17003
16972
- function getGlobalBuiltinIteratorType(reportErrors: boolean) {
16973
- return (deferredGlobalBuiltinIteratorType ||= getGlobalType("BuiltinIterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
17004
+ function getBuiltinIteratorReturnType() {
17005
+ return strictBuiltinIteratorReturn ? undefinedType : anyType;
17006
+ }
17007
+
17008
+ function getGlobalBuiltinIteratorTypes() {
17009
+ // NOTE: This list does not include all built-in iterator types, only those that are likely to be encountered frequently.
17010
+ return deferredGlobalBuiltinIteratorTypes ??= getGlobalBuiltinTypes(["ArrayIterator", "MapIterator", "SetIterator", "StringIterator"], 1);
17011
+ }
17012
+
17013
+ function getGlobalIteratorObjectType(reportErrors: boolean) {
17014
+ return (deferredGlobalIteratorObjectType ||= getGlobalType("IteratorObject" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
16974
17015
}
16975
17016
16976
17017
function getGlobalGeneratorType(reportErrors: boolean) {
@@ -44951,18 +44992,32 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
44951
44992
// As an optimization, if the type is an instantiation of the following global type, then
44952
44993
// just grab its related type arguments:
44953
44994
// - `Iterable<T, TReturn, TNext>` or `AsyncIterable<T, TReturn, TNext>`
44954
- // - `BuiltinIterator <T, TReturn, TNext>` or `BuiltinAsyncIterator <T, TReturn, TNext>`
44995
+ // - `IteratorObject <T, TReturn, TNext>` or `AsyncIteratorObject <T, TReturn, TNext>`
44955
44996
// - `IterableIterator<T, TReturn, TNext>` or `AsyncIterableIterator<T, TReturn, TNext>`
44956
44997
// - `Generator<T, TReturn, TNext>` or `AsyncGenerator<T, TReturn, TNext>`
44957
44998
if (
44958
44999
isReferenceToType(type, resolver.getGlobalIterableType(/*reportErrors*/ false)) ||
44959
- isReferenceToType(type, resolver.getGlobalBuiltinIteratorType (/*reportErrors*/ false)) ||
45000
+ isReferenceToType(type, resolver.getGlobalIteratorObjectType (/*reportErrors*/ false)) ||
44960
45001
isReferenceToType(type, resolver.getGlobalIterableIteratorType(/*reportErrors*/ false)) ||
44961
45002
isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false))
44962
45003
) {
44963
45004
const [yieldType, returnType, nextType] = getTypeArguments(type as GenericType);
44964
45005
return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, /*errorNode*/ undefined) || yieldType, resolver.resolveIterationType(returnType, /*errorNode*/ undefined) || returnType, nextType));
44965
45006
}
45007
+
45008
+ // As an optimization, if the type is an instantiation of one of the following global types, then
45009
+ // just grab the related type argument:
45010
+ // - `ArrayIterator<T>`
45011
+ // - `MapIterator<T>`
45012
+ // - `SetIterator<T>`
45013
+ // - `StringIterator<T>`
45014
+ // - `ReadableStreamAsyncIterator<T>`
45015
+ if (isReferenceToSomeType(type, resolver.getGlobalBuiltinIteratorTypes())) {
45016
+ const [yieldType] = getTypeArguments(type as GenericType);
45017
+ const returnType = getBuiltinIteratorReturnType();
45018
+ const nextType = unknownType;
45019
+ return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, /*errorNode*/ undefined) || yieldType, resolver.resolveIterationType(returnType, /*errorNode*/ undefined) || returnType, nextType));
45020
+ }
44966
45021
}
44967
45022
44968
45023
function getPropertyNameForKnownSymbolName(symbolName: string): __String {
@@ -45079,18 +45134,32 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
45079
45134
// As an optimization, if the type is an instantiation of one of the following global types,
45080
45135
// then just grab its related type arguments:
45081
45136
// - `IterableIterator<T, TReturn, TNext>` or `AsyncIterableIterator<T, TReturn, TNext>`
45082
- // - `BuiltinIterator <T, TReturn, TNext>` or `BuiltinAsyncIterator <T, TReturn, TNext>`
45137
+ // - `IteratorObject <T, TReturn, TNext>` or `AsyncIteratorObject <T, TReturn, TNext>`
45083
45138
// - `Iterator<T, TReturn, TNext>` or `AsyncIterator<T, TReturn, TNext>`
45084
45139
// - `Generator<T, TReturn, TNext>` or `AsyncGenerator<T, TReturn, TNext>`
45085
45140
if (
45086
- isReferenceToType(type, resolver.getGlobalBuiltinIteratorType(/*reportErrors*/ false)) ||
45087
45141
isReferenceToType(type, resolver.getGlobalIterableIteratorType(/*reportErrors*/ false)) ||
45088
45142
isReferenceToType(type, resolver.getGlobalIteratorType(/*reportErrors*/ false)) ||
45143
+ isReferenceToType(type, resolver.getGlobalIteratorObjectType(/*reportErrors*/ false)) ||
45089
45144
isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false))
45090
45145
) {
45091
45146
const [yieldType, returnType, nextType] = getTypeArguments(type as GenericType);
45092
45147
return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
45093
45148
}
45149
+
45150
+ // As an optimization, if the type is an instantiation of one of the following global types, then
45151
+ // just grab the related type argument:
45152
+ // - `ArrayIterator<T>`
45153
+ // - `MapIterator<T>`
45154
+ // - `SetIterator<T>`
45155
+ // - `StringIterator<T>`
45156
+ // - `ReadableStreamAsyncIterator<T>`
45157
+ if (isReferenceToSomeType(type, resolver.getGlobalBuiltinIteratorTypes())) {
45158
+ const [yieldType] = getTypeArguments(type as GenericType);
45159
+ const returnType = getBuiltinIteratorReturnType();
45160
+ const nextType = unknownType;
45161
+ return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
45162
+ }
45094
45163
}
45095
45164
45096
45165
function isIteratorResult(type: Type, kind: IterationTypeKind.Yield | IterationTypeKind.Return) {
0 commit comments