diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 49f179bf6b087..46f45be58218f 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1499,6 +1499,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { var strictFunctionTypes = getStrictOptionValue(compilerOptions, "strictFunctionTypes"); var strictBindCallApply = getStrictOptionValue(compilerOptions, "strictBindCallApply"); var strictPropertyInitialization = getStrictOptionValue(compilerOptions, "strictPropertyInitialization"); + var strictBuiltinIteratorReturn = getStrictOptionValue(compilerOptions, "strictBuiltinIteratorReturn"); var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny"); var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis"); var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables"); @@ -1823,10 +1824,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { getOptionalType: () => optionalType, getPromiseType: () => getGlobalPromiseType(/*reportErrors*/ false), getPromiseLikeType: () => getGlobalPromiseLikeType(/*reportErrors*/ false), - getAsyncIterableType: () => { + getAnyAsyncIterableType: () => { const type = getGlobalAsyncIterableType(/*reportErrors*/ false); if (type === emptyGenericType) return undefined; - return type; + return createTypeReference(type, [anyType, anyType, anyType]); }, isSymbolAccessible, isArrayType, @@ -2150,8 +2151,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { }; var anyIterationTypes = createIterationTypes(anyType, anyType, anyType); - var anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType); - var defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType); // default iteration types for `Iterator`. var asyncIterationTypesResolver: IterationTypesResolver = { iterableCacheKey: "iterationTypesOfAsyncIterable", @@ -6877,7 +6876,37 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } let typeArgumentNodes: readonly TypeNode[] | undefined; if (typeArguments.length > 0) { - const typeParameterCount = (type.target.typeParameters || emptyArray).length; + let typeParameterCount = 0; + if (type.target.typeParameters) { + typeParameterCount = Math.min(type.target.typeParameters.length, typeArguments.length); + + // Maybe we should do this for more types, but for now we only elide type arguments that are + // identical to their associated type parameters' defaults for `Iterable`, `IterableIterator`, + // `AsyncIterable`, and `AsyncIterableIterator` to provide backwards-compatible .d.ts emit due + // to each now having three type parameters instead of only one. + if ( + isReferenceToType(type, getGlobalIterableType(/*reportErrors*/ false)) || + isReferenceToType(type, getGlobalIterableIteratorType(/*reportErrors*/ false)) || + isReferenceToType(type, getGlobalAsyncIterableType(/*reportErrors*/ false)) || + isReferenceToType(type, getGlobalAsyncIterableIteratorType(/*reportErrors*/ false)) + ) { + if ( + !type.node || !isTypeReferenceNode(type.node) || !type.node.typeArguments || + type.node.typeArguments.length < typeParameterCount + ) { + while (typeParameterCount > 0) { + const typeArgument = typeArguments[typeParameterCount - 1]; + const typeParameter = type.target.typeParameters[typeParameterCount - 1]; + const defaultType = getDefaultFromTypeParameter(typeParameter); + if (!defaultType || !isTypeIdenticalTo(typeArgument, defaultType)) { + break; + } + typeParameterCount--; + } + } + } + } + typeArgumentNodes = mapToTypeNodes(typeArguments.slice(i, typeParameterCount), context); } const flags = context.flags; @@ -12943,7 +12972,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const typeNode = isJSDocTypeAlias(declaration) ? declaration.typeExpression : declaration.type; // If typeNode is missing, we will error in checkJSDocTypedefTag. let type = typeNode ? getTypeFromTypeNode(typeNode) : errorType; - if (popTypeResolution()) { const typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); if (typeParameters) { @@ -12953,6 +12981,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { links.instantiations = new Map(); links.instantiations.set(getTypeListId(typeParameters), type); } + if (type === intrinsicMarkerType && symbol.escapedName === "BuiltinIteratorReturn") { + type = strictBuiltinIteratorReturn ? undefinedType : anyType; + } } else { type = errorType; @@ -16888,7 +16919,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function getGlobalAsyncIterableType(reportErrors: boolean) { - return (deferredGlobalAsyncIterableType ||= getGlobalType("AsyncIterable" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType; + return (deferredGlobalAsyncIterableType ||= getGlobalType("AsyncIterable" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType; } function getGlobalAsyncIteratorType(reportErrors: boolean) { @@ -16896,7 +16927,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function getGlobalAsyncIterableIteratorType(reportErrors: boolean) { - return (deferredGlobalAsyncIterableIteratorType ||= getGlobalType("AsyncIterableIterator" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType; + return (deferredGlobalAsyncIterableIteratorType ||= getGlobalType("AsyncIterableIterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType; } function getGlobalAsyncGeneratorType(reportErrors: boolean) { @@ -16904,7 +16935,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function getGlobalIterableType(reportErrors: boolean) { - return (deferredGlobalIterableType ||= getGlobalType("Iterable" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType; + return (deferredGlobalIterableType ||= getGlobalType("Iterable" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType; } function getGlobalIteratorType(reportErrors: boolean) { @@ -16912,7 +16943,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function getGlobalIterableIteratorType(reportErrors: boolean) { - return (deferredGlobalIterableIteratorType ||= getGlobalType("IterableIterator" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType; + return (deferredGlobalIterableIteratorType ||= getGlobalType("IterableIterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType; } function getGlobalGeneratorType(reportErrors: boolean) { @@ -17015,7 +17046,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function createIterableType(iteratedType: Type): Type { - return createTypeFromGenericGlobalType(getGlobalIterableType(/*reportErrors*/ true), [iteratedType]); + return createTypeFromGenericGlobalType(getGlobalIterableType(/*reportErrors*/ true), [iteratedType, voidType, undefinedType]); } function createArrayType(elementType: Type, readonly?: boolean): ObjectType { @@ -38207,28 +38238,14 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { returnType = resolver.resolveIterationType(returnType, /*errorNode*/ undefined) || unknownType; nextType = resolver.resolveIterationType(nextType, /*errorNode*/ undefined) || unknownType; if (globalGeneratorType === emptyGenericType) { - // Fall back to the global IterableIterator if returnType is assignable to the expected return iteration - // type of IterableIterator, and the expected next iteration type of IterableIterator is assignable to - // nextType. - const globalType = resolver.getGlobalIterableIteratorType(/*reportErrors*/ false); - const iterationTypes = globalType !== emptyGenericType ? getIterationTypesOfGlobalIterableType(globalType, resolver) : undefined; - const iterableIteratorReturnType = iterationTypes ? iterationTypes.returnType : anyType; - const iterableIteratorNextType = iterationTypes ? iterationTypes.nextType : undefinedType; - if ( - isTypeAssignableTo(returnType, iterableIteratorReturnType) && - isTypeAssignableTo(iterableIteratorNextType, nextType) - ) { - if (globalType !== emptyGenericType) { - return createTypeFromGenericGlobalType(globalType, [yieldType]); - } - - // The global IterableIterator type doesn't exist, so report an error - resolver.getGlobalIterableIteratorType(/*reportErrors*/ true); - return emptyObjectType; + // Fall back to the global IterableIterator type. + const globalIterableIteratorType = resolver.getGlobalIterableIteratorType(/*reportErrors*/ false); + if (globalIterableIteratorType !== emptyGenericType) { + return createTypeFromGenericGlobalType(globalIterableIteratorType, [yieldType, returnType, nextType]); } // The global Generator type doesn't exist, so report an error - resolver.getGlobalGeneratorType(/*reportErrors*/ true); + resolver.getGlobalIterableIteratorType(/*reportErrors*/ true); return emptyObjectType; } @@ -44738,12 +44755,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return getCachedIterationTypes(type, resolver.iterableCacheKey); } - function getIterationTypesOfGlobalIterableType(globalType: Type, resolver: IterationTypesResolver) { - const globalIterationTypes = getIterationTypesOfIterableCached(globalType, resolver) || - getIterationTypesOfIterableSlow(globalType, resolver, /*errorNode*/ undefined, /*errorOutputContainer*/ undefined, /*noCache*/ false); - return globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes; - } - /** * Gets the *yield*, *return*, and *next* types of an `Iterable`-like or `AsyncIterable`-like * type from from common heuristics. @@ -44757,28 +44768,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { * `getIterationTypesOfIterable` instead. */ function getIterationTypesOfIterableFast(type: Type, resolver: IterationTypesResolver) { - // As an optimization, if the type is an instantiation of one of the following global types, then - // just grab its related type argument: - // - `Iterable` or `AsyncIterable` - // - `IterableIterator` or `AsyncIterableIterator` - let globalType: Type; - if ( - isReferenceToType(type, globalType = resolver.getGlobalIterableType(/*reportErrors*/ false)) || - isReferenceToType(type, globalType = resolver.getGlobalIterableIteratorType(/*reportErrors*/ false)) - ) { - const [yieldType] = getTypeArguments(type as GenericType); - // The "return" and "next" types of `Iterable` and `IterableIterator` are defined by the - // iteration types of their `[Symbol.iterator]()` method. The same is true for their async cousins. - // While we define these as `any` and `undefined` in our libs by default, a custom lib *could* use - // different definitions. - const { returnType, nextType } = getIterationTypesOfGlobalIterableType(globalType, resolver); - return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, /*errorNode*/ undefined) || yieldType, resolver.resolveIterationType(returnType, /*errorNode*/ undefined) || returnType, nextType)); - } - // As an optimization, if the type is an instantiation of the following global type, then // just grab its related type arguments: + // - `Iterable` or `AsyncIterable` + // - `IterableIterator` or `AsyncIterableIterator` // - `Generator` or `AsyncGenerator` - if (isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false))) { + if ( + isReferenceToType(type, resolver.getGlobalIterableType(/*reportErrors*/ false)) || + isReferenceToType(type, resolver.getGlobalIterableIteratorType(/*reportErrors*/ false)) || + isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false)) + ) { const [yieldType, returnType, nextType] = getTypeArguments(type as GenericType); return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, /*errorNode*/ undefined) || yieldType, resolver.resolveIterationType(returnType, /*errorNode*/ undefined) || returnType, nextType)); } @@ -44830,7 +44829,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { isForOfStatement(errorNode.parent) && errorNode.parent.expression === errorNode && getGlobalAsyncIterableType(/*reportErrors*/ false) !== emptyGenericType && - isTypeAssignableTo(type, getGlobalAsyncIterableType(/*reportErrors*/ false)) + isTypeAssignableTo(type, createTypeFromGenericGlobalType(getGlobalAsyncIterableType(/*reportErrors*/ false), [anyType, anyType, anyType])) ); return errorAndMaybeSuggestAwait(errorNode, suggestAwait, message, typeToString(type)); } @@ -44896,22 +44895,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { */ function getIterationTypesOfIteratorFast(type: Type, resolver: IterationTypesResolver) { // As an optimization, if the type is an instantiation of one of the following global types, - // then just grab its related type argument: - // - `IterableIterator` or `AsyncIterableIterator` + // then just grab its related type arguments: + // - `IterableIterator` or `AsyncIterableIterator` // - `Iterator` or `AsyncIterator` // - `Generator` or `AsyncGenerator` - const globalType = resolver.getGlobalIterableIteratorType(/*reportErrors*/ false); - if (isReferenceToType(type, globalType)) { - const [yieldType] = getTypeArguments(type as GenericType); - // The "return" and "next" types of `IterableIterator` and `AsyncIterableIterator` are defined by the - // iteration types of their `next`, `return`, and `throw` methods. While we define these as `any` - // and `undefined` in our libs by default, a custom lib *could* use different definitions. - const globalIterationTypes = getIterationTypesOfIteratorCached(globalType, resolver) || - getIterationTypesOfIteratorSlow(globalType, resolver, /*errorNode*/ undefined, /*errorOutputContainer*/ undefined, /*noCache*/ false); - const { returnType, nextType } = globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes; - return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType)); - } if ( + isReferenceToType(type, resolver.getGlobalIterableIteratorType(/*reportErrors*/ false)) || isReferenceToType(type, resolver.getGlobalIteratorType(/*reportErrors*/ false)) || isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false)) ) { @@ -45003,8 +44992,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { : undefined; if (isTypeAny(methodType)) { - // `return()` and `throw()` don't provide a *next* type. - return methodName === "next" ? anyIterationTypes : anyIterationTypesExceptNext; + return anyIterationTypes; } // Both async and non-async iterators *must* have a `next` method. @@ -46463,7 +46451,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { checkExportsOnMergedDeclarations(node); checkTypeParameters(node.typeParameters); if (node.type.kind === SyntaxKind.IntrinsicKeyword) { - if (!intrinsicTypeKinds.has(node.name.escapedText as string) || length(node.typeParameters) !== 1) { + const typeParameterCount = length(node.typeParameters); + const valid = typeParameterCount === 0 ? node.name.escapedText === "BuiltinIteratorReturn" : + typeParameterCount === 1 && intrinsicTypeKinds.has(node.name.escapedText as string); + if (!valid) { error(node.type, Diagnostics.The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types); } } diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 25b5895544c30..11a2b5d273b2d 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -915,6 +915,16 @@ const commandOptionsWithoutBuild: CommandLineOption[] = [ description: Diagnostics.Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor, defaultValueDescription: Diagnostics.false_unless_strict_is_set, }, + { + name: "strictBuiltinIteratorReturn", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsBuildInfo: true, + strictFlag: true, + category: Diagnostics.Type_Checking, + description: Diagnostics.Built_in_iterators_are_instantiated_with_a_TReturn_type_of_undefined_instead_of_any, + defaultValueDescription: Diagnostics.false_unless_strict_is_set, + }, { name: "noImplicitThis", type: "boolean", diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index e71ee7671d19c..89db25cd731e7 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -6368,6 +6368,10 @@ "code": 6719 }, + "Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'.": { + "category": "Message", + "code": 6720 + }, "Default catch clause variables as 'unknown' instead of 'any'.": { "category": "Message", "code": 6803 diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 0a1d95e8ce637..83c18e197e216 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -5237,7 +5237,7 @@ export interface TypeChecker { /** @internal */ createPromiseType(type: Type): Type; /** @internal */ getPromiseType(): Type; /** @internal */ getPromiseLikeType(): Type; - /** @internal */ getAsyncIterableType(): Type | undefined; + /** @internal */ getAnyAsyncIterableType(): Type | undefined; /** * Returns true if the "source" type is assignable to the "target" type. @@ -7407,6 +7407,7 @@ export interface CompilerOptions { strictBindCallApply?: boolean; // Always combine with strict property strictNullChecks?: boolean; // Always combine with strict property strictPropertyInitialization?: boolean; // Always combine with strict property + strictBuiltinIteratorReturn?: boolean; // Always combine with strict property stripInternal?: boolean; /** @deprecated */ suppressExcessPropertyErrors?: boolean; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 76759fe0ece01..b29944a5236c3 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -9006,6 +9006,12 @@ export const computedOptions = createComputedCompilerOptions({ return getStrictOptionValue(compilerOptions, "strictPropertyInitialization"); }, }, + strictBuiltinIteratorReturn: { + dependencies: ["strict"], + computeValue: compilerOptions => { + return getStrictOptionValue(compilerOptions, "strictBuiltinIteratorReturn"); + }, + }, alwaysStrict: { dependencies: ["strict"], computeValue: compilerOptions => { @@ -9093,6 +9099,7 @@ export type StrictOptionName = | "strictFunctionTypes" | "strictBindCallApply" | "strictPropertyInitialization" + | "strictBuiltinIteratorReturn" | "alwaysStrict" | "useUnknownInCatchVariables"; diff --git a/src/harness/collectionsImpl.ts b/src/harness/collectionsImpl.ts index 7b0a859d0fcbc..6c0da4353a987 100644 --- a/src/harness/collectionsImpl.ts +++ b/src/harness/collectionsImpl.ts @@ -132,6 +132,7 @@ export class SortedMap { this._copyOnWrite = false; } } + return undefined; } public *values() { @@ -154,6 +155,7 @@ export class SortedMap { this._copyOnWrite = false; } } + return undefined; } public *entries() { @@ -179,6 +181,7 @@ export class SortedMap { this._copyOnWrite = false; } } + return undefined; } public [Symbol.iterator]() { diff --git a/src/lib/dom.iterable.d.ts b/src/lib/dom.iterable.d.ts index 8ffbcd4811b55..747f279099191 100644 --- a/src/lib/dom.iterable.d.ts +++ b/src/lib/dom.iterable.d.ts @@ -1,30 +1,30 @@ /// interface DOMTokenList { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; } interface Headers { - [Symbol.iterator](): IterableIterator<[string, string]>; + [Symbol.iterator](): IterableIterator<[string, string], BuiltinIteratorReturn>; /** * Returns an iterator allowing to go through all key/value pairs contained in this object. */ - entries(): IterableIterator<[string, string]>; + entries(): IterableIterator<[string, string], BuiltinIteratorReturn>; /** * Returns an iterator allowing to go through all keys f the key/value pairs contained in this object. */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an iterator allowing to go through all values of the key/value pairs contained in this object. */ - values(): IterableIterator; + values(): IterableIterator; } interface NodeList { /** * Returns an array of key, value pairs for every entry in the list */ - entries(): IterableIterator<[number, Node]>; + entries(): IterableIterator<[number, Node], BuiltinIteratorReturn>; /** * Performs the specified action for each node in an list. * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list. @@ -34,21 +34,21 @@ interface NodeList { /** * Returns an list of keys in the list */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an list of values in the list */ - values(): IterableIterator; + values(): IterableIterator; - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; } interface NodeListOf { /** * Returns an array of key, value pairs for every entry in the list */ - entries(): IterableIterator<[number, TNode]>; + entries(): IterableIterator<[number, TNode], BuiltinIteratorReturn>; /** * Performs the specified action for each node in an list. @@ -59,55 +59,55 @@ interface NodeListOf { /** * Returns an list of keys in the list */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an list of values in the list */ - values(): IterableIterator; + values(): IterableIterator; - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; } interface HTMLCollectionBase { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; } interface HTMLCollectionOf { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; } interface FormData { /** * Returns an array of key, value pairs for every entry in the list */ - entries(): IterableIterator<[string, string | File]>; + entries(): IterableIterator<[string, string | File], BuiltinIteratorReturn>; /** * Returns a list of keys in the list */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns a list of values in the list */ - values(): IterableIterator; + values(): IterableIterator; - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; } interface URLSearchParams { /** * Returns an array of key, value pairs for every entry in the search params */ - entries(): IterableIterator<[string, string]>; + entries(): IterableIterator<[string, string], BuiltinIteratorReturn>; /** * Returns a list of keys in the search params */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns a list of values in the search params */ - values(): IterableIterator; + values(): IterableIterator; /** * iterate over key/value pairs */ - [Symbol.iterator](): IterableIterator<[string, string]>; + [Symbol.iterator](): IterableIterator<[string, string], BuiltinIteratorReturn>; } diff --git a/src/lib/es2015.generator.d.ts b/src/lib/es2015.generator.d.ts index 7c6929173a0e4..064260fc47023 100644 --- a/src/lib/es2015.generator.d.ts +++ b/src/lib/es2015.generator.d.ts @@ -1,6 +1,6 @@ /// -interface Generator extends Iterator { +interface Generator extends Iterator { // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places. next(...args: [] | [TNext]): IteratorResult; return(value: TReturn): IteratorResult; diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts index d28b8381eec86..9ea54b67f7c45 100644 --- a/src/lib/es2015.iterable.d.ts +++ b/src/lib/es2015.iterable.d.ts @@ -20,39 +20,41 @@ interface IteratorReturnResult { type IteratorResult = IteratorYieldResult | IteratorReturnResult; -interface Iterator { +interface Iterator { // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places. next(...args: [] | [TNext]): IteratorResult; return?(value?: TReturn): IteratorResult; throw?(e?: any): IteratorResult; } -interface Iterable { - [Symbol.iterator](): Iterator; +interface Iterable { + [Symbol.iterator](): Iterator; } -interface IterableIterator extends Iterator { - [Symbol.iterator](): IterableIterator; +interface IterableIterator extends Iterator { + [Symbol.iterator](): IterableIterator; } +type BuiltinIteratorReturn = intrinsic; + interface Array { /** Iterator */ - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an iterable of key, value pairs for every entry in the array */ - entries(): IterableIterator<[number, T]>; + entries(): IterableIterator<[number, T], BuiltinIteratorReturn>; /** * Returns an iterable of keys in the array */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an iterable of values in the array */ - values(): IterableIterator; + values(): IterableIterator; } interface ArrayConstructor { @@ -73,67 +75,67 @@ interface ArrayConstructor { interface ReadonlyArray { /** Iterator of values in the array. */ - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an iterable of key, value pairs for every entry in the array */ - entries(): IterableIterator<[number, T]>; + entries(): IterableIterator<[number, T], BuiltinIteratorReturn>; /** * Returns an iterable of keys in the array */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an iterable of values in the array */ - values(): IterableIterator; + values(): IterableIterator; } interface IArguments { /** Iterator */ - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; } interface Map { /** Returns an iterable of entries in the map. */ - [Symbol.iterator](): IterableIterator<[K, V]>; + [Symbol.iterator](): IterableIterator<[K, V], BuiltinIteratorReturn>; /** * Returns an iterable of key, value pairs for every entry in the map. */ - entries(): IterableIterator<[K, V]>; + entries(): IterableIterator<[K, V], BuiltinIteratorReturn>; /** * Returns an iterable of keys in the map */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an iterable of values in the map */ - values(): IterableIterator; + values(): IterableIterator; } interface ReadonlyMap { /** Returns an iterable of entries in the map. */ - [Symbol.iterator](): IterableIterator<[K, V]>; + [Symbol.iterator](): IterableIterator<[K, V], BuiltinIteratorReturn>; /** * Returns an iterable of key, value pairs for every entry in the map. */ - entries(): IterableIterator<[K, V]>; + entries(): IterableIterator<[K, V], BuiltinIteratorReturn>; /** * Returns an iterable of keys in the map */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an iterable of values in the map */ - values(): IterableIterator; + values(): IterableIterator; } interface MapConstructor { @@ -149,40 +151,40 @@ interface WeakMapConstructor { interface Set { /** Iterates over values in the set. */ - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an iterable of [v,v] pairs for every value `v` in the set. */ - entries(): IterableIterator<[T, T]>; + entries(): IterableIterator<[T, T], BuiltinIteratorReturn>; /** * Despite its name, returns an iterable of the values in the set. */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an iterable of values in the set. */ - values(): IterableIterator; + values(): IterableIterator; } interface ReadonlySet { /** Iterates over values in the set. */ - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an iterable of [v,v] pairs for every value `v` in the set. */ - entries(): IterableIterator<[T, T]>; + entries(): IterableIterator<[T, T], BuiltinIteratorReturn>; /** * Despite its name, returns an iterable of the values in the set. */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an iterable of values in the set. */ - values(): IterableIterator; + values(): IterableIterator; } interface SetConstructor { @@ -217,23 +219,23 @@ interface PromiseConstructor { interface String { /** Iterator */ - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; } interface Int8Array { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an array of key, value pairs for every entry in the array */ - entries(): IterableIterator<[number, number]>; + entries(): IterableIterator<[number, number], BuiltinIteratorReturn>; /** * Returns an list of keys in the array */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an list of values in the array */ - values(): IterableIterator; + values(): IterableIterator; } interface Int8ArrayConstructor { @@ -249,19 +251,19 @@ interface Int8ArrayConstructor { } interface Uint8Array { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an array of key, value pairs for every entry in the array */ - entries(): IterableIterator<[number, number]>; + entries(): IterableIterator<[number, number], BuiltinIteratorReturn>; /** * Returns an list of keys in the array */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an list of values in the array */ - values(): IterableIterator; + values(): IterableIterator; } interface Uint8ArrayConstructor { @@ -277,21 +279,21 @@ interface Uint8ArrayConstructor { } interface Uint8ClampedArray { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an array of key, value pairs for every entry in the array */ - entries(): IterableIterator<[number, number]>; + entries(): IterableIterator<[number, number], BuiltinIteratorReturn>; /** * Returns an list of keys in the array */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an list of values in the array */ - values(): IterableIterator; + values(): IterableIterator; } interface Uint8ClampedArrayConstructor { @@ -307,21 +309,21 @@ interface Uint8ClampedArrayConstructor { } interface Int16Array { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an array of key, value pairs for every entry in the array */ - entries(): IterableIterator<[number, number]>; + entries(): IterableIterator<[number, number], BuiltinIteratorReturn>; /** * Returns an list of keys in the array */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an list of values in the array */ - values(): IterableIterator; + values(): IterableIterator; } interface Int16ArrayConstructor { @@ -337,19 +339,19 @@ interface Int16ArrayConstructor { } interface Uint16Array { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an array of key, value pairs for every entry in the array */ - entries(): IterableIterator<[number, number]>; + entries(): IterableIterator<[number, number], BuiltinIteratorReturn>; /** * Returns an list of keys in the array */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an list of values in the array */ - values(): IterableIterator; + values(): IterableIterator; } interface Uint16ArrayConstructor { @@ -365,19 +367,19 @@ interface Uint16ArrayConstructor { } interface Int32Array { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an array of key, value pairs for every entry in the array */ - entries(): IterableIterator<[number, number]>; + entries(): IterableIterator<[number, number], BuiltinIteratorReturn>; /** * Returns an list of keys in the array */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an list of values in the array */ - values(): IterableIterator; + values(): IterableIterator; } interface Int32ArrayConstructor { @@ -393,19 +395,19 @@ interface Int32ArrayConstructor { } interface Uint32Array { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an array of key, value pairs for every entry in the array */ - entries(): IterableIterator<[number, number]>; + entries(): IterableIterator<[number, number], BuiltinIteratorReturn>; /** * Returns an list of keys in the array */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an list of values in the array */ - values(): IterableIterator; + values(): IterableIterator; } interface Uint32ArrayConstructor { @@ -421,19 +423,19 @@ interface Uint32ArrayConstructor { } interface Float32Array { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an array of key, value pairs for every entry in the array */ - entries(): IterableIterator<[number, number]>; + entries(): IterableIterator<[number, number], BuiltinIteratorReturn>; /** * Returns an list of keys in the array */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an list of values in the array */ - values(): IterableIterator; + values(): IterableIterator; } interface Float32ArrayConstructor { @@ -449,19 +451,19 @@ interface Float32ArrayConstructor { } interface Float64Array { - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; /** * Returns an array of key, value pairs for every entry in the array */ - entries(): IterableIterator<[number, number]>; + entries(): IterableIterator<[number, number], BuiltinIteratorReturn>; /** * Returns an list of keys in the array */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns an list of values in the array */ - values(): IterableIterator; + values(): IterableIterator; } interface Float64ArrayConstructor { diff --git a/src/lib/es2018.asyncgenerator.d.ts b/src/lib/es2018.asyncgenerator.d.ts index f6966264c8be4..8ce3ba23a4d47 100644 --- a/src/lib/es2018.asyncgenerator.d.ts +++ b/src/lib/es2018.asyncgenerator.d.ts @@ -1,6 +1,6 @@ /// -interface AsyncGenerator extends AsyncIterator { +interface AsyncGenerator extends AsyncIterator { // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places. next(...args: [] | [TNext]): Promise>; return(value: TReturn | PromiseLike): Promise>; diff --git a/src/lib/es2018.asynciterable.d.ts b/src/lib/es2018.asynciterable.d.ts index 0fe799e21055e..5b868867f430d 100644 --- a/src/lib/es2018.asynciterable.d.ts +++ b/src/lib/es2018.asynciterable.d.ts @@ -9,17 +9,17 @@ interface SymbolConstructor { readonly asyncIterator: unique symbol; } -interface AsyncIterator { +interface AsyncIterator { // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places. next(...args: [] | [TNext]): Promise>; return?(value?: TReturn | PromiseLike): Promise>; throw?(e?: any): Promise>; } -interface AsyncIterable { - [Symbol.asyncIterator](): AsyncIterator; +interface AsyncIterable { + [Symbol.asyncIterator](): AsyncIterator; } -interface AsyncIterableIterator extends AsyncIterator { - [Symbol.asyncIterator](): AsyncIterableIterator; +interface AsyncIterableIterator extends AsyncIterator { + [Symbol.asyncIterator](): AsyncIterableIterator; } diff --git a/src/lib/es2020.bigint.d.ts b/src/lib/es2020.bigint.d.ts index b4b46c7d9bb15..e5cafc442d677 100644 --- a/src/lib/es2020.bigint.d.ts +++ b/src/lib/es2020.bigint.d.ts @@ -153,7 +153,7 @@ interface BigInt64Array { copyWithin(target: number, start: number, end?: number): this; /** Yields index, value pairs for every entry in the array. */ - entries(): IterableIterator<[number, bigint]>; + entries(): IterableIterator<[number, bigint], BuiltinIteratorReturn>; /** * Determines whether all the members of an array satisfy the specified test. @@ -238,7 +238,7 @@ interface BigInt64Array { join(separator?: string): string; /** Yields each index in the array. */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -360,9 +360,9 @@ interface BigInt64Array { valueOf(): BigInt64Array; /** Yields each value in the array. */ - values(): IterableIterator; + values(): IterableIterator; - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; readonly [Symbol.toStringTag]: "BigInt64Array"; @@ -425,7 +425,7 @@ interface BigUint64Array { copyWithin(target: number, start: number, end?: number): this; /** Yields index, value pairs for every entry in the array. */ - entries(): IterableIterator<[number, bigint]>; + entries(): IterableIterator<[number, bigint], BuiltinIteratorReturn>; /** * Determines whether all the members of an array satisfy the specified test. @@ -510,7 +510,7 @@ interface BigUint64Array { join(separator?: string): string; /** Yields each index in the array. */ - keys(): IterableIterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -632,9 +632,9 @@ interface BigUint64Array { valueOf(): BigUint64Array; /** Yields each value in the array. */ - values(): IterableIterator; + values(): IterableIterator; - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; readonly [Symbol.toStringTag]: "BigUint64Array"; diff --git a/src/lib/es2020.string.d.ts b/src/lib/es2020.string.d.ts index bc7cf1ad5f7c3..7f7911d517d02 100644 --- a/src/lib/es2020.string.d.ts +++ b/src/lib/es2020.string.d.ts @@ -6,7 +6,7 @@ interface String { * containing the results of that search. * @param regexp A variable name or string literal containing the regular expression pattern and flags. */ - matchAll(regexp: RegExp): IterableIterator; + matchAll(regexp: RegExp): IterableIterator; /** Converts all alphabetic characters to lowercase, taking into account the host environment's current locale. */ toLocaleLowerCase(locales?: Intl.LocalesArgument): string; diff --git a/src/lib/es2020.symbol.wellknown.d.ts b/src/lib/es2020.symbol.wellknown.d.ts index 94a11768256c7..0a65134b7c2d2 100644 --- a/src/lib/es2020.symbol.wellknown.d.ts +++ b/src/lib/es2020.symbol.wellknown.d.ts @@ -15,5 +15,5 @@ interface RegExp { * containing the results of that search. * @param string A string to search within. */ - [Symbol.matchAll](str: string): IterableIterator; + [Symbol.matchAll](str: string): IterableIterator; } diff --git a/src/lib/es2022.intl.d.ts b/src/lib/es2022.intl.d.ts index 3beaea6af8ddd..e92a67f7a88d6 100644 --- a/src/lib/es2022.intl.d.ts +++ b/src/lib/es2022.intl.d.ts @@ -37,7 +37,7 @@ declare namespace Intl { containing(codeUnitIndex?: number): SegmentData; /** Returns an iterator to iterate over the segments. */ - [Symbol.iterator](): IterableIterator; + [Symbol.iterator](): IterableIterator; } interface SegmentData { diff --git a/src/services/codefixes/addMissingAwait.ts b/src/services/codefixes/addMissingAwait.ts index 0fc96ba514b37..7f874b5801517 100644 --- a/src/services/codefixes/addMissingAwait.ts +++ b/src/services/codefixes/addMissingAwait.ts @@ -285,7 +285,7 @@ function isInsideAwaitableBody(node: Node) { function makeChange(changeTracker: textChanges.ChangeTracker, errorCode: number, sourceFile: SourceFile, checker: TypeChecker, insertionSite: Expression, fixedDeclarations?: Set) { if (isForOfStatement(insertionSite.parent) && !insertionSite.parent.awaitModifier) { const exprType = checker.getTypeAtLocation(insertionSite); - const asyncIter = checker.getAsyncIterableType(); + const asyncIter = checker.getAnyAsyncIterableType(); if (asyncIter && checker.isTypeAssignableTo(exprType, asyncIter)) { const forOf = insertionSite.parent; changeTracker.replaceNode(sourceFile, forOf, factory.updateForOfStatement(forOf, factory.createToken(SyntaxKind.AwaitKeyword), forOf.initializer, forOf.expression, forOf.statement)); diff --git a/src/testRunner/compilerRunner.ts b/src/testRunner/compilerRunner.ts index 93bc55c1159fe..8ec63a8b7b921 100644 --- a/src/testRunner/compilerRunner.ts +++ b/src/testRunner/compilerRunner.ts @@ -127,44 +127,32 @@ export class CompilerBaselineRunner extends RunnerBase { class CompilerTest { private static varyBy: readonly string[] = [ - "allowArbitraryExtensions", - "allowImportingTsExtensions", - "allowSyntheticDefaultImports", - "alwaysStrict", - "downlevelIteration", - "experimentalDecorators", - "emitDecoratorMetadata", - "esModuleInterop", - "exactOptionalPropertyTypes", - "importHelpers", - "importHelpers", - "isolatedModules", - "jsx", - "module", - "moduleDetection", - "moduleResolution", + // implicit variations from defined options + ...ts.optionDeclarations + .filter(option => + !option.isCommandLineOnly + && ( + option.type === "boolean" + || typeof option.type === "object" + ) + && ( + option.affectsProgramStructure + || option.affectsEmit + || option.affectsModuleResolution + || option.affectsBindDiagnostics + || option.affectsSemanticDiagnostics + || option.affectsSourceFile + || option.affectsDeclarationPath + || option.affectsBuildInfo + ) + ) + .map(option => option.name), + + // explicit variations that do not match above conditions "noEmit", - "noImplicitAny", - "noImplicitThis", - "noPropertyAccessFromIndexSignature", - "noUncheckedIndexedAccess", - "preserveConstEnums", - "removeComments", - "resolveJsonModule", - "resolvePackageJsonExports", - "resolvePackageJsonImports", - "skipDefaultLibCheck", - "skipLibCheck", - "strict", - "strictBindCallApply", - "strictFunctionTypes", - "strictNullChecks", - "strictPropertyInitialization", - "target", - "useDefineForClassFields", - "useUnknownInCatchVariables", - "verbatimModuleSyntax", + "isolatedModules", ]; + private fileName: string; private justName: string; private configuredName: string; diff --git a/tests/baselines/reference/YieldStarExpression4_es6.types b/tests/baselines/reference/YieldStarExpression4_es6.types index 5a84b1bba080b..c2c8b54fde262 100644 --- a/tests/baselines/reference/YieldStarExpression4_es6.types +++ b/tests/baselines/reference/YieldStarExpression4_es6.types @@ -2,8 +2,8 @@ === YieldStarExpression4_es6.ts === function *g() { ->g : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>g : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield * []; >yield * [] : any diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index f76ecc40be329..3855078b1f285 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -7008,6 +7008,7 @@ declare namespace ts { strictBindCallApply?: boolean; strictNullChecks?: boolean; strictPropertyInitialization?: boolean; + strictBuiltinIteratorReturn?: boolean; stripInternal?: boolean; /** @deprecated */ suppressExcessPropertyErrors?: boolean; diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.types b/tests/baselines/reference/argumentsObjectIterator02_ES6.types index a2dd6ad1ecc2a..4dd2e090a434c 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES6.types +++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.types @@ -12,10 +12,10 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe > : ^^^^^^ let blah = arguments[Symbol.iterator]; ->blah : () => IterableIterator -> : ^^^^^^ ->arguments[Symbol.iterator] : () => IterableIterator -> : ^^^^^^ +>blah : () => IterableIterator +> : ^^^^^^ +>arguments[Symbol.iterator] : () => IterableIterator +> : ^^^^^^ >arguments : IArguments > : ^^^^^^^^^^ >Symbol.iterator : unique symbol @@ -35,8 +35,8 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe >arg : any >blah() : IterableIterator > : ^^^^^^^^^^^^^^^^^^^^^ ->blah : () => IterableIterator -> : ^^^^^^ +>blah : () => IterableIterator +> : ^^^^^^ result.push(arg + arg); >result.push(arg + arg) : number diff --git a/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=false).symbols b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=false).symbols new file mode 100644 index 0000000000000..121fa7517084d --- /dev/null +++ b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=false).symbols @@ -0,0 +1,125 @@ +//// [tests/cases/conformance/types/typeAliases/builtinIteratorReturn.ts] //// + +=== builtinIteratorReturn.ts === +declare const array: number[]; +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) + +declare const map: Map; +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +declare const set: Set; +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.collection.d.ts, --, --)) + +const i0 = array[Symbol.iterator](); +>i0 : Symbol(i0, Decl(builtinIteratorReturn.ts, 4, 5)) +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i1 = array.values(); +>i1 : Symbol(i1, Decl(builtinIteratorReturn.ts, 5, 5)) +>array.values : Symbol(Array.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) +>values : Symbol(Array.values, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i2 = array.keys(); +>i2 : Symbol(i2, Decl(builtinIteratorReturn.ts, 6, 5)) +>array.keys : Symbol(Array.keys, Decl(lib.es2015.iterable.d.ts, --, --)) +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) +>keys : Symbol(Array.keys, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i3 = array.entries(); +>i3 : Symbol(i3, Decl(builtinIteratorReturn.ts, 7, 5)) +>array.entries : Symbol(Array.entries, Decl(lib.es2015.iterable.d.ts, --, --)) +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) +>entries : Symbol(Array.entries, Decl(lib.es2015.iterable.d.ts, --, --)) + +for (const x of array); +>x : Symbol(x, Decl(builtinIteratorReturn.ts, 8, 10)) +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) + +const i4 = map[Symbol.iterator](); +>i4 : Symbol(i4, Decl(builtinIteratorReturn.ts, 10, 5)) +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i5 = map.values(); +>i5 : Symbol(i5, Decl(builtinIteratorReturn.ts, 11, 5)) +>map.values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) +>values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i6 = map.keys(); +>i6 : Symbol(i6, Decl(builtinIteratorReturn.ts, 12, 5)) +>map.keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) +>keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i7 = map.entries(); +>i7 : Symbol(i7, Decl(builtinIteratorReturn.ts, 13, 5)) +>map.entries : Symbol(Map.entries, Decl(lib.es2015.iterable.d.ts, --, --)) +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) +>entries : Symbol(Map.entries, Decl(lib.es2015.iterable.d.ts, --, --)) + +for (const x of map); +>x : Symbol(x, Decl(builtinIteratorReturn.ts, 14, 10)) +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) + +const i8 = set[Symbol.iterator](); +>i8 : Symbol(i8, Decl(builtinIteratorReturn.ts, 16, 5)) +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i9 = set.values(); +>i9 : Symbol(i9, Decl(builtinIteratorReturn.ts, 17, 5)) +>set.values : Symbol(Set.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) +>values : Symbol(Set.values, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i10 = set.keys(); +>i10 : Symbol(i10, Decl(builtinIteratorReturn.ts, 18, 5)) +>set.keys : Symbol(Set.keys, Decl(lib.es2015.iterable.d.ts, --, --)) +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) +>keys : Symbol(Set.keys, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i11 = set.entries(); +>i11 : Symbol(i11, Decl(builtinIteratorReturn.ts, 19, 5)) +>set.entries : Symbol(Set.entries, Decl(lib.es2015.iterable.d.ts, --, --)) +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) +>entries : Symbol(Set.entries, Decl(lib.es2015.iterable.d.ts, --, --)) + +for (const x of set); +>x : Symbol(x, Decl(builtinIteratorReturn.ts, 20, 10)) +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) + +declare const i12: IterableIterator; +>i12 : Symbol(i12, Decl(builtinIteratorReturn.ts, 22, 13)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const i13: IterableIterator; +>i13 : Symbol(i13, Decl(builtinIteratorReturn.ts, 23, 13)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const i14: IterableIterator; +>i14 : Symbol(i14, Decl(builtinIteratorReturn.ts, 24, 13)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const i15: Iterable; +>i15 : Symbol(i15, Decl(builtinIteratorReturn.ts, 25, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const i16: Iterable; +>i16 : Symbol(i16, Decl(builtinIteratorReturn.ts, 26, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const i17: Iterable; +>i17 : Symbol(i17, Decl(builtinIteratorReturn.ts, 27, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + diff --git a/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=false).types b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=false).types new file mode 100644 index 0000000000000..914c702b1317f --- /dev/null +++ b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=false).types @@ -0,0 +1,213 @@ +//// [tests/cases/conformance/types/typeAliases/builtinIteratorReturn.ts] //// + +=== builtinIteratorReturn.ts === +declare const array: number[]; +>array : number[] +> : ^^^^^^^^ + +declare const map: Map; +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ + +declare const set: Set; +>set : Set +> : ^^^^^^^^^^^ + +const i0 = array[Symbol.iterator](); +>i0 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>array[Symbol.iterator]() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>array[Symbol.iterator] : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array : number[] +> : ^^^^^^^^ +>Symbol.iterator : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>iterator : unique symbol +> : ^^^^^^^^^^^^^ + +const i1 = array.values(); +>i1 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>array.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>array.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array : number[] +> : ^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +const i2 = array.keys(); +>i2 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>array.keys() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>array.keys : () => IterableIterator +> : ^^^^^^ +>array : number[] +> : ^^^^^^^^ +>keys : () => IterableIterator +> : ^^^^^^ + +const i3 = array.entries(); +>i3 : IterableIterator<[number, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array.entries() : IterableIterator<[number, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array.entries : () => IterableIterator<[number, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array : number[] +> : ^^^^^^^^ +>entries : () => IterableIterator<[number, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +for (const x of array); +>x : number +> : ^^^^^^ +>array : number[] +> : ^^^^^^^^ + +const i4 = map[Symbol.iterator](); +>i4 : IterableIterator<[string, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map[Symbol.iterator]() : IterableIterator<[string, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map[Symbol.iterator] : () => IterableIterator<[string, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>Symbol.iterator : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>iterator : unique symbol +> : ^^^^^^^^^^^^^ + +const i5 = map.values(); +>i5 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +const i6 = map.keys(); +>i6 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>map.keys() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>map.keys : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>keys : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +const i7 = map.entries(); +>i7 : IterableIterator<[string, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.entries() : IterableIterator<[string, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.entries : () => IterableIterator<[string, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>entries : () => IterableIterator<[string, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +for (const x of map); +>x : [string, number] +> : ^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ + +const i8 = set[Symbol.iterator](); +>i8 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>set[Symbol.iterator]() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>set[Symbol.iterator] : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set : Set +> : ^^^^^^^^^^^ +>Symbol.iterator : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>iterator : unique symbol +> : ^^^^^^^^^^^^^ + +const i9 = set.values(); +>i9 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>set.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>set.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set : Set +> : ^^^^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +const i10 = set.keys(); +>i10 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>set.keys() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>set.keys : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set : Set +> : ^^^^^^^^^^^ +>keys : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +const i11 = set.entries(); +>i11 : IterableIterator<[number, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.entries() : IterableIterator<[number, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.entries : () => IterableIterator<[number, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set : Set +> : ^^^^^^^^^^^ +>entries : () => IterableIterator<[number, number]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +for (const x of set); +>x : number +> : ^^^^^^ +>set : Set +> : ^^^^^^^^^^^ + +declare const i12: IterableIterator; +>i12 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +declare const i13: IterableIterator; +>i13 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ + +declare const i14: IterableIterator; +>i14 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +declare const i15: Iterable; +>i15 : Iterable +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +declare const i16: Iterable; +>i16 : Iterable +> : ^^^^^^^^^^^^^^^^ + +declare const i17: Iterable; +>i17 : Iterable +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + diff --git a/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=true).symbols b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=true).symbols new file mode 100644 index 0000000000000..121fa7517084d --- /dev/null +++ b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=true).symbols @@ -0,0 +1,125 @@ +//// [tests/cases/conformance/types/typeAliases/builtinIteratorReturn.ts] //// + +=== builtinIteratorReturn.ts === +declare const array: number[]; +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) + +declare const map: Map; +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +declare const set: Set; +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.collection.d.ts, --, --)) + +const i0 = array[Symbol.iterator](); +>i0 : Symbol(i0, Decl(builtinIteratorReturn.ts, 4, 5)) +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i1 = array.values(); +>i1 : Symbol(i1, Decl(builtinIteratorReturn.ts, 5, 5)) +>array.values : Symbol(Array.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) +>values : Symbol(Array.values, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i2 = array.keys(); +>i2 : Symbol(i2, Decl(builtinIteratorReturn.ts, 6, 5)) +>array.keys : Symbol(Array.keys, Decl(lib.es2015.iterable.d.ts, --, --)) +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) +>keys : Symbol(Array.keys, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i3 = array.entries(); +>i3 : Symbol(i3, Decl(builtinIteratorReturn.ts, 7, 5)) +>array.entries : Symbol(Array.entries, Decl(lib.es2015.iterable.d.ts, --, --)) +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) +>entries : Symbol(Array.entries, Decl(lib.es2015.iterable.d.ts, --, --)) + +for (const x of array); +>x : Symbol(x, Decl(builtinIteratorReturn.ts, 8, 10)) +>array : Symbol(array, Decl(builtinIteratorReturn.ts, 0, 13)) + +const i4 = map[Symbol.iterator](); +>i4 : Symbol(i4, Decl(builtinIteratorReturn.ts, 10, 5)) +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i5 = map.values(); +>i5 : Symbol(i5, Decl(builtinIteratorReturn.ts, 11, 5)) +>map.values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) +>values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i6 = map.keys(); +>i6 : Symbol(i6, Decl(builtinIteratorReturn.ts, 12, 5)) +>map.keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) +>keys : Symbol(Map.keys, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i7 = map.entries(); +>i7 : Symbol(i7, Decl(builtinIteratorReturn.ts, 13, 5)) +>map.entries : Symbol(Map.entries, Decl(lib.es2015.iterable.d.ts, --, --)) +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) +>entries : Symbol(Map.entries, Decl(lib.es2015.iterable.d.ts, --, --)) + +for (const x of map); +>x : Symbol(x, Decl(builtinIteratorReturn.ts, 14, 10)) +>map : Symbol(map, Decl(builtinIteratorReturn.ts, 1, 13)) + +const i8 = set[Symbol.iterator](); +>i8 : Symbol(i8, Decl(builtinIteratorReturn.ts, 16, 5)) +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i9 = set.values(); +>i9 : Symbol(i9, Decl(builtinIteratorReturn.ts, 17, 5)) +>set.values : Symbol(Set.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) +>values : Symbol(Set.values, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i10 = set.keys(); +>i10 : Symbol(i10, Decl(builtinIteratorReturn.ts, 18, 5)) +>set.keys : Symbol(Set.keys, Decl(lib.es2015.iterable.d.ts, --, --)) +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) +>keys : Symbol(Set.keys, Decl(lib.es2015.iterable.d.ts, --, --)) + +const i11 = set.entries(); +>i11 : Symbol(i11, Decl(builtinIteratorReturn.ts, 19, 5)) +>set.entries : Symbol(Set.entries, Decl(lib.es2015.iterable.d.ts, --, --)) +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) +>entries : Symbol(Set.entries, Decl(lib.es2015.iterable.d.ts, --, --)) + +for (const x of set); +>x : Symbol(x, Decl(builtinIteratorReturn.ts, 20, 10)) +>set : Symbol(set, Decl(builtinIteratorReturn.ts, 2, 13)) + +declare const i12: IterableIterator; +>i12 : Symbol(i12, Decl(builtinIteratorReturn.ts, 22, 13)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const i13: IterableIterator; +>i13 : Symbol(i13, Decl(builtinIteratorReturn.ts, 23, 13)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const i14: IterableIterator; +>i14 : Symbol(i14, Decl(builtinIteratorReturn.ts, 24, 13)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const i15: Iterable; +>i15 : Symbol(i15, Decl(builtinIteratorReturn.ts, 25, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const i16: Iterable; +>i16 : Symbol(i16, Decl(builtinIteratorReturn.ts, 26, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const i17: Iterable; +>i17 : Symbol(i17, Decl(builtinIteratorReturn.ts, 27, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + diff --git a/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=true).types b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=true).types new file mode 100644 index 0000000000000..f0ffe8c1d63c6 --- /dev/null +++ b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=true).types @@ -0,0 +1,213 @@ +//// [tests/cases/conformance/types/typeAliases/builtinIteratorReturn.ts] //// + +=== builtinIteratorReturn.ts === +declare const array: number[]; +>array : number[] +> : ^^^^^^^^ + +declare const map: Map; +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ + +declare const set: Set; +>set : Set +> : ^^^^^^^^^^^ + +const i0 = array[Symbol.iterator](); +>i0 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array[Symbol.iterator]() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array[Symbol.iterator] : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array : number[] +> : ^^^^^^^^ +>Symbol.iterator : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>iterator : unique symbol +> : ^^^^^^^^^^^^^ + +const i1 = array.values(); +>i1 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array : number[] +> : ^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +const i2 = array.keys(); +>i2 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array.keys() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array.keys : () => IterableIterator +> : ^^^^^^ +>array : number[] +> : ^^^^^^^^ +>keys : () => IterableIterator +> : ^^^^^^ + +const i3 = array.entries(); +>i3 : IterableIterator<[number, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array.entries() : IterableIterator<[number, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array.entries : () => IterableIterator<[number, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>array : number[] +> : ^^^^^^^^ +>entries : () => IterableIterator<[number, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +for (const x of array); +>x : number +> : ^^^^^^ +>array : number[] +> : ^^^^^^^^ + +const i4 = map[Symbol.iterator](); +>i4 : IterableIterator<[string, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map[Symbol.iterator]() : IterableIterator<[string, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map[Symbol.iterator] : () => IterableIterator<[string, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>Symbol.iterator : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>iterator : unique symbol +> : ^^^^^^^^^^^^^ + +const i5 = map.values(); +>i5 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +const i6 = map.keys(); +>i6 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.keys() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.keys : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>keys : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +const i7 = map.entries(); +>i7 : IterableIterator<[string, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.entries() : IterableIterator<[string, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.entries : () => IterableIterator<[string, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>entries : () => IterableIterator<[string, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +for (const x of map); +>x : [string, number] +> : ^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ + +const i8 = set[Symbol.iterator](); +>i8 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set[Symbol.iterator]() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set[Symbol.iterator] : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set : Set +> : ^^^^^^^^^^^ +>Symbol.iterator : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>iterator : unique symbol +> : ^^^^^^^^^^^^^ + +const i9 = set.values(); +>i9 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set : Set +> : ^^^^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +const i10 = set.keys(); +>i10 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.keys() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.keys : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set : Set +> : ^^^^^^^^^^^ +>keys : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +const i11 = set.entries(); +>i11 : IterableIterator<[number, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.entries() : IterableIterator<[number, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.entries : () => IterableIterator<[number, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set : Set +> : ^^^^^^^^^^^ +>entries : () => IterableIterator<[number, number], undefined> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +for (const x of set); +>x : number +> : ^^^^^^ +>set : Set +> : ^^^^^^^^^^^ + +declare const i12: IterableIterator; +>i12 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +declare const i13: IterableIterator; +>i13 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ + +declare const i14: IterableIterator; +>i14 : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +declare const i15: Iterable; +>i15 : Iterable +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +declare const i16: Iterable; +>i16 : Iterable +> : ^^^^^^^^^^^^^^^^ + +declare const i17: Iterable; +>i17 : Iterable +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + diff --git a/tests/baselines/reference/conditionalTypeDoesntSpinForever.types b/tests/baselines/reference/conditionalTypeDoesntSpinForever.types index 73fb1f2d6e19d..9d9489fd8ddff 100644 --- a/tests/baselines/reference/conditionalTypeDoesntSpinForever.types +++ b/tests/baselines/reference/conditionalTypeDoesntSpinForever.types @@ -1,8 +1,8 @@ //// [tests/cases/compiler/conditionalTypeDoesntSpinForever.ts] //// === Performance Stats === -Type Count: 1,000 -Instantiation count: 2,500 -> 5,000 +Type Count: 1,000 -> 2,500 +Instantiation count: 5,000 === conditionalTypeDoesntSpinForever.ts === // A *self-contained* demonstration of the problem follows... diff --git a/tests/baselines/reference/config/initTSConfig/Default initialized TSConfig/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Default initialized TSConfig/tsconfig.json index 4c3a3cb096410..a7774be58c9d5 100644 --- a/tests/baselines/reference/config/initTSConfig/Default initialized TSConfig/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Default initialized TSConfig/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --help/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --help/tsconfig.json index 4c3a3cb096410..a7774be58c9d5 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --help/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --help/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --watch/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --watch/tsconfig.json index 4c3a3cb096410..a7774be58c9d5 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --watch/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --watch/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with advanced options/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with advanced options/tsconfig.json index edb7ea2b9b349..705b9f76e0100 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with advanced options/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with advanced options/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json index e01c1d7bb35dc..ebe2ee57e9069 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with enum value compiler options/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with enum value compiler options/tsconfig.json index e0614bfc14e17..46fb71d52c392 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with enum value compiler options/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with enum value compiler options/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with files options/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with files options/tsconfig.json index ef17a1a4dcfb2..300866f96a856 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with files options/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with files options/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json index 015e6dc8a3c76..8a8db313c2111 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json index 4c3a3cb096410..a7774be58c9d5 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json index b153779e49c2b..84f23824275f2 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options/tsconfig.json b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options/tsconfig.json index 9120ea674fb57..6494b47ae9ebb 100644 --- a/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options/tsconfig.json +++ b/tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options/tsconfig.json @@ -87,6 +87,7 @@ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */ // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ diff --git a/tests/baselines/reference/config/showConfig/Show TSConfig with compileOnSave and more/tsconfig.json b/tests/baselines/reference/config/showConfig/Show TSConfig with compileOnSave and more/tsconfig.json index 27dff8d0b2c57..7796a64971d56 100644 --- a/tests/baselines/reference/config/showConfig/Show TSConfig with compileOnSave and more/tsconfig.json +++ b/tests/baselines/reference/config/showConfig/Show TSConfig with compileOnSave and more/tsconfig.json @@ -11,6 +11,7 @@ "strictFunctionTypes": true, "strictBindCallApply": true, "strictPropertyInitialization": true, + "strictBuiltinIteratorReturn": true, "alwaysStrict": true, "useUnknownInCatchVariables": true }, diff --git a/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strict/tsconfig.json b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strict/tsconfig.json index a94c9ac06ee71..cb5f15904a123 100644 --- a/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strict/tsconfig.json +++ b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strict/tsconfig.json @@ -7,6 +7,7 @@ "strictFunctionTypes": true, "strictBindCallApply": true, "strictPropertyInitialization": true, + "strictBuiltinIteratorReturn": true, "alwaysStrict": true, "useUnknownInCatchVariables": true } diff --git a/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strictBuiltinIteratorReturn/tsconfig.json b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strictBuiltinIteratorReturn/tsconfig.json new file mode 100644 index 0000000000000..090835c267e13 --- /dev/null +++ b/tests/baselines/reference/config/showConfig/Shows tsconfig for single option/strictBuiltinIteratorReturn/tsconfig.json @@ -0,0 +1,5 @@ +{ + "compilerOptions": { + "strictBuiltinIteratorReturn": true + } +} diff --git a/tests/baselines/reference/customAsyncIterator.js b/tests/baselines/reference/customAsyncIterator.js index 31bdd76778077..ea31a03b69d83 100644 --- a/tests/baselines/reference/customAsyncIterator.js +++ b/tests/baselines/reference/customAsyncIterator.js @@ -2,7 +2,7 @@ //// [customAsyncIterator.ts] // GH: https://github.com/microsoft/TypeScript/issues/33239 -class ConstantIterator implements AsyncIterator { +class ConstantIterator implements AsyncIterator { constructor(private constant: T) { } async next(value?: T): Promise> { diff --git a/tests/baselines/reference/customAsyncIterator.symbols b/tests/baselines/reference/customAsyncIterator.symbols index 641a24f86108a..8e6b7d5f05b45 100644 --- a/tests/baselines/reference/customAsyncIterator.symbols +++ b/tests/baselines/reference/customAsyncIterator.symbols @@ -2,7 +2,7 @@ === customAsyncIterator.ts === // GH: https://github.com/microsoft/TypeScript/issues/33239 -class ConstantIterator implements AsyncIterator { +class ConstantIterator implements AsyncIterator { >ConstantIterator : Symbol(ConstantIterator, Decl(customAsyncIterator.ts, 0, 0)) >T : Symbol(T, Decl(customAsyncIterator.ts, 1, 23)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --)) diff --git a/tests/baselines/reference/customAsyncIterator.types b/tests/baselines/reference/customAsyncIterator.types index a31d06fdf7ee9..bbf9a8209ac27 100644 --- a/tests/baselines/reference/customAsyncIterator.types +++ b/tests/baselines/reference/customAsyncIterator.types @@ -2,7 +2,7 @@ === customAsyncIterator.ts === // GH: https://github.com/microsoft/TypeScript/issues/33239 -class ConstantIterator implements AsyncIterator { +class ConstantIterator implements AsyncIterator { >ConstantIterator : ConstantIterator > : ^^^^^^^^^^^^^^^^^^^ diff --git a/tests/baselines/reference/dependentDestructuredVariables.types b/tests/baselines/reference/dependentDestructuredVariables.types index 52e4690a91f2b..287dfb004259e 100644 --- a/tests/baselines/reference/dependentDestructuredVariables.types +++ b/tests/baselines/reference/dependentDestructuredVariables.types @@ -789,8 +789,8 @@ const reducerBroken = (state: number, { type, payload }: Action3) => { // Repro from #46143 declare var it: Iterator; ->it : Iterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>it : Iterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ const { value, done } = it.next(); >value : any @@ -799,12 +799,12 @@ const { value, done } = it.next(); > : ^^^^^^^^^^^^^^^^^^^ >it.next() : IteratorResult > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->it.next : (...args: [] | [undefined]) => IteratorResult -> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->it : Iterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->next : (...args: [] | [undefined]) => IteratorResult -> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>it.next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>it : Iterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ +>next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ if (!done) { >!done : boolean diff --git a/tests/baselines/reference/destructuringAssignmentWithDefault2.types b/tests/baselines/reference/destructuringAssignmentWithDefault2.types index 864ec12dff585..b3a2c81120575 100644 --- a/tests/baselines/reference/destructuringAssignmentWithDefault2.types +++ b/tests/baselines/reference/destructuringAssignmentWithDefault2.types @@ -147,8 +147,8 @@ const { x: z3 = undefined } = a; declare const r: Iterator; ->r : Iterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>r : Iterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ let done: boolean; >done : boolean @@ -173,12 +173,12 @@ let value; > : ^^^ >r.next() : IteratorResult > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->r.next : (...args: [] | [undefined]) => IteratorResult -> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->r : Iterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->next : (...args: [] | [undefined]) => IteratorResult -> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>r.next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>r : Iterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ +>next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ({ done: done = false, value } = r.next()); >({ done: done = false, value } = r.next()) : IteratorResult @@ -199,10 +199,10 @@ let value; > : ^^^ >r.next() : IteratorResult > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->r.next : (...args: [] | [undefined]) => IteratorResult -> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->r : Iterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->next : (...args: [] | [undefined]) => IteratorResult -> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>r.next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>r : Iterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ +>next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).symbols b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).symbols index 16a1e57d1b016..92e1297495f1b 100644 --- a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).symbols +++ b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).symbols @@ -16,16 +16,17 @@ function mapAsyncIterable( >U : Symbol(U, Decl(discriminateWithOptionalProperty2.ts, 4, 28)) >R : Symbol(R, Decl(discriminateWithOptionalProperty2.ts, 4, 31)) - iterable: AsyncGenerator | AsyncIterable, + iterable: AsyncGenerator | AsyncIterable, >iterable : Symbol(iterable, Decl(discriminateWithOptionalProperty2.ts, 4, 47)) >AsyncGenerator : Symbol(AsyncGenerator, Decl(lib.es2018.asyncgenerator.d.ts, --, --)) >T : Symbol(T, Decl(discriminateWithOptionalProperty2.ts, 4, 26)) >R : Symbol(R, Decl(discriminateWithOptionalProperty2.ts, 4, 31)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --)) >T : Symbol(T, Decl(discriminateWithOptionalProperty2.ts, 4, 26)) +>R : Symbol(R, Decl(discriminateWithOptionalProperty2.ts, 4, 31)) callback: (value: T) => PromiseOrValue, ->callback : Symbol(callback, Decl(discriminateWithOptionalProperty2.ts, 5, 58)) +>callback : Symbol(callback, Decl(discriminateWithOptionalProperty2.ts, 5, 77)) >value : Symbol(value, Decl(discriminateWithOptionalProperty2.ts, 6, 13)) >T : Symbol(T, Decl(discriminateWithOptionalProperty2.ts, 4, 26)) >PromiseOrValue : Symbol(PromiseOrValue, Decl(discriminateWithOptionalProperty2.ts, 0, 0)) @@ -70,7 +71,7 @@ function mapAsyncIterable( try { return { value: await callback(result.value), done: false }; >value : Symbol(value, Decl(discriminateWithOptionalProperty2.ts, 18, 14)) ->callback : Symbol(callback, Decl(discriminateWithOptionalProperty2.ts, 5, 58)) +>callback : Symbol(callback, Decl(discriminateWithOptionalProperty2.ts, 5, 77)) >result.value : Symbol(IteratorYieldResult.value, Decl(lib.es2015.iterable.d.ts, --, --)) >result : Symbol(result, Decl(discriminateWithOptionalProperty2.ts, 10, 27)) >value : Symbol(IteratorYieldResult.value, Decl(lib.es2015.iterable.d.ts, --, --)) diff --git a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).types b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).types index b6b348657dfee..c378f82199043 100644 --- a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).types +++ b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).types @@ -8,12 +8,12 @@ type PromiseOrValue = Promise | T; > : ^^^^^^^^^^^^^^^^^ function mapAsyncIterable( ->mapAsyncIterable : (iterable: AsyncGenerator | AsyncIterable, callback: (value: T) => PromiseOrValue) => AsyncGenerator -> : ^ ^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>mapAsyncIterable : (iterable: AsyncGenerator | AsyncIterable, callback: (value: T) => PromiseOrValue) => AsyncGenerator +> : ^ ^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ - iterable: AsyncGenerator | AsyncIterable, ->iterable : AsyncGenerator | AsyncIterable -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + iterable: AsyncGenerator | AsyncIterable, +>iterable : AsyncGenerator | AsyncIterable +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ callback: (value: T) => PromiseOrValue, >callback : (value: T) => PromiseOrValue @@ -23,14 +23,14 @@ function mapAsyncIterable( ): AsyncGenerator { const iterator = iterable[Symbol.asyncIterator](); ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterable[Symbol.asyncIterator]() : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterable[Symbol.asyncIterator] : (() => AsyncGenerator) | (() => AsyncIterator) -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterable : AsyncGenerator | AsyncIterable -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterable[Symbol.asyncIterator]() : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterable[Symbol.asyncIterator] : (() => AsyncGenerator) | (() => AsyncIterator) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterable : AsyncGenerator | AsyncIterable +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Symbol.asyncIterator : unique symbol > : ^^^^^^^^^^^^^ >Symbol : SymbolConstructor @@ -92,27 +92,27 @@ function mapAsyncIterable( > : ^^^^^^^ >typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return : ((value?: any) => Promise>) | undefined -> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->return : ((value?: any) => Promise>) | undefined -> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.return : ((value?: R | PromiseLike | undefined) => Promise>) | undefined +> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>return : ((value?: R | PromiseLike | undefined) => Promise>) | undefined +> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >"function" : "function" > : ^^^^^^^^^^ try { await iterator.return(); ->await iterator.return() : IteratorResult -> : ^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return() : Promise> -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return : (value?: any) => Promise> -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->return : (value?: any) => Promise> -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>await iterator.return() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^ +>iterator.return() : Promise> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.return : (value?: R | PromiseLike | undefined) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>return : (value?: R | PromiseLike | undefined) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ } catch (_e) {} >_e : unknown @@ -137,16 +137,16 @@ function mapAsyncIterable( > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >mapResult : (result: IteratorResult) => Promise> > : ^ ^^ ^^^^^ ->await iterator.next() : IteratorResult -> : ^^^^^^^^^^^^^^^^^^^^^^ ->iterator.next() : Promise> -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.next : (...args: [] | [undefined]) => Promise> -> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->next : (...args: [] | [undefined]) => Promise> -> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>await iterator.next() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^ +>iterator.next() : Promise> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.next : (...args: [] | [undefined]) => Promise> +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>next : (...args: [] | [undefined]) => Promise> +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ }, async return(): Promise> { @@ -160,12 +160,12 @@ function mapAsyncIterable( > : ^^^^^^^ >typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return : ((value?: any) => Promise>) | undefined -> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->return : ((value?: any) => Promise>) | undefined -> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.return : ((value?: R | PromiseLike | undefined) => Promise>) | undefined +> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>return : ((value?: R | PromiseLike | undefined) => Promise>) | undefined +> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >"function" : "function" > : ^^^^^^^^^^ @@ -174,16 +174,16 @@ function mapAsyncIterable( > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >mapResult : (result: IteratorResult) => Promise> > : ^ ^^ ^^^^^ ->await iterator.return() : IteratorResult -> : ^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return() : Promise> -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return : (value?: any) => Promise> -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->return : (value?: any) => Promise> -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>await iterator.return() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^ +>iterator.return() : Promise> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.return : (value?: R | PromiseLike | undefined) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>return : (value?: R | PromiseLike | undefined) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ : { value: undefined as any, done: true }; >{ value: undefined as any, done: true } : { value: any; done: true; } @@ -209,12 +209,12 @@ function mapAsyncIterable( > : ^^^^^^^ >typeof iterator.throw : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.throw : ((e?: any) => Promise>) | undefined -> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->throw : ((e?: any) => Promise>) | undefined -> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.throw : ((e?: any) => Promise>) | undefined +> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>throw : ((e?: any) => Promise>) | undefined +> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >"function" : "function" > : ^^^^^^^^^^ @@ -223,16 +223,16 @@ function mapAsyncIterable( > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >mapResult : (result: IteratorResult) => Promise> > : ^ ^^ ^^^^^ ->await iterator.throw(error) : IteratorResult -> : ^^^^^^^^^^^^^^^^^^^^^^ ->iterator.throw(error) : Promise> -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.throw : (e?: any) => Promise> -> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->throw : (e?: any) => Promise> -> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>await iterator.throw(error) : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^ +>iterator.throw(error) : Promise> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.throw : (e?: any) => Promise> +> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>throw : (e?: any) => Promise> +> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >error : unknown > : ^^^^^^^ } @@ -355,8 +355,8 @@ const doubles = mapAsyncIterable(iterable, (x) => x + x); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >mapAsyncIterable(iterable, (x) => x + x) : AsyncGenerator > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->mapAsyncIterable : (iterable: AsyncGenerator | AsyncIterable, callback: (value: T) => PromiseOrValue) => AsyncGenerator -> : ^ ^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>mapAsyncIterable : (iterable: AsyncGenerator | AsyncIterable, callback: (value: T) => PromiseOrValue) => AsyncGenerator +> : ^ ^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ >iterable : { [Symbol.asyncIterator](): any; next(): Promise<{ done: boolean; value: number; }>; } > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(x) => x + x : (x: number) => number diff --git a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).symbols b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).symbols index 16a1e57d1b016..92e1297495f1b 100644 --- a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).symbols +++ b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).symbols @@ -16,16 +16,17 @@ function mapAsyncIterable( >U : Symbol(U, Decl(discriminateWithOptionalProperty2.ts, 4, 28)) >R : Symbol(R, Decl(discriminateWithOptionalProperty2.ts, 4, 31)) - iterable: AsyncGenerator | AsyncIterable, + iterable: AsyncGenerator | AsyncIterable, >iterable : Symbol(iterable, Decl(discriminateWithOptionalProperty2.ts, 4, 47)) >AsyncGenerator : Symbol(AsyncGenerator, Decl(lib.es2018.asyncgenerator.d.ts, --, --)) >T : Symbol(T, Decl(discriminateWithOptionalProperty2.ts, 4, 26)) >R : Symbol(R, Decl(discriminateWithOptionalProperty2.ts, 4, 31)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --)) >T : Symbol(T, Decl(discriminateWithOptionalProperty2.ts, 4, 26)) +>R : Symbol(R, Decl(discriminateWithOptionalProperty2.ts, 4, 31)) callback: (value: T) => PromiseOrValue, ->callback : Symbol(callback, Decl(discriminateWithOptionalProperty2.ts, 5, 58)) +>callback : Symbol(callback, Decl(discriminateWithOptionalProperty2.ts, 5, 77)) >value : Symbol(value, Decl(discriminateWithOptionalProperty2.ts, 6, 13)) >T : Symbol(T, Decl(discriminateWithOptionalProperty2.ts, 4, 26)) >PromiseOrValue : Symbol(PromiseOrValue, Decl(discriminateWithOptionalProperty2.ts, 0, 0)) @@ -70,7 +71,7 @@ function mapAsyncIterable( try { return { value: await callback(result.value), done: false }; >value : Symbol(value, Decl(discriminateWithOptionalProperty2.ts, 18, 14)) ->callback : Symbol(callback, Decl(discriminateWithOptionalProperty2.ts, 5, 58)) +>callback : Symbol(callback, Decl(discriminateWithOptionalProperty2.ts, 5, 77)) >result.value : Symbol(IteratorYieldResult.value, Decl(lib.es2015.iterable.d.ts, --, --)) >result : Symbol(result, Decl(discriminateWithOptionalProperty2.ts, 10, 27)) >value : Symbol(IteratorYieldResult.value, Decl(lib.es2015.iterable.d.ts, --, --)) diff --git a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).types b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).types index b6b348657dfee..c378f82199043 100644 --- a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).types +++ b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).types @@ -8,12 +8,12 @@ type PromiseOrValue = Promise | T; > : ^^^^^^^^^^^^^^^^^ function mapAsyncIterable( ->mapAsyncIterable : (iterable: AsyncGenerator | AsyncIterable, callback: (value: T) => PromiseOrValue) => AsyncGenerator -> : ^ ^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>mapAsyncIterable : (iterable: AsyncGenerator | AsyncIterable, callback: (value: T) => PromiseOrValue) => AsyncGenerator +> : ^ ^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ - iterable: AsyncGenerator | AsyncIterable, ->iterable : AsyncGenerator | AsyncIterable -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + iterable: AsyncGenerator | AsyncIterable, +>iterable : AsyncGenerator | AsyncIterable +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ callback: (value: T) => PromiseOrValue, >callback : (value: T) => PromiseOrValue @@ -23,14 +23,14 @@ function mapAsyncIterable( ): AsyncGenerator { const iterator = iterable[Symbol.asyncIterator](); ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterable[Symbol.asyncIterator]() : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterable[Symbol.asyncIterator] : (() => AsyncGenerator) | (() => AsyncIterator) -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterable : AsyncGenerator | AsyncIterable -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterable[Symbol.asyncIterator]() : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterable[Symbol.asyncIterator] : (() => AsyncGenerator) | (() => AsyncIterator) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterable : AsyncGenerator | AsyncIterable +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Symbol.asyncIterator : unique symbol > : ^^^^^^^^^^^^^ >Symbol : SymbolConstructor @@ -92,27 +92,27 @@ function mapAsyncIterable( > : ^^^^^^^ >typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return : ((value?: any) => Promise>) | undefined -> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->return : ((value?: any) => Promise>) | undefined -> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.return : ((value?: R | PromiseLike | undefined) => Promise>) | undefined +> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>return : ((value?: R | PromiseLike | undefined) => Promise>) | undefined +> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >"function" : "function" > : ^^^^^^^^^^ try { await iterator.return(); ->await iterator.return() : IteratorResult -> : ^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return() : Promise> -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return : (value?: any) => Promise> -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->return : (value?: any) => Promise> -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>await iterator.return() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^ +>iterator.return() : Promise> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.return : (value?: R | PromiseLike | undefined) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>return : (value?: R | PromiseLike | undefined) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ } catch (_e) {} >_e : unknown @@ -137,16 +137,16 @@ function mapAsyncIterable( > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >mapResult : (result: IteratorResult) => Promise> > : ^ ^^ ^^^^^ ->await iterator.next() : IteratorResult -> : ^^^^^^^^^^^^^^^^^^^^^^ ->iterator.next() : Promise> -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.next : (...args: [] | [undefined]) => Promise> -> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->next : (...args: [] | [undefined]) => Promise> -> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>await iterator.next() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^ +>iterator.next() : Promise> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.next : (...args: [] | [undefined]) => Promise> +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>next : (...args: [] | [undefined]) => Promise> +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ }, async return(): Promise> { @@ -160,12 +160,12 @@ function mapAsyncIterable( > : ^^^^^^^ >typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return : ((value?: any) => Promise>) | undefined -> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->return : ((value?: any) => Promise>) | undefined -> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.return : ((value?: R | PromiseLike | undefined) => Promise>) | undefined +> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>return : ((value?: R | PromiseLike | undefined) => Promise>) | undefined +> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >"function" : "function" > : ^^^^^^^^^^ @@ -174,16 +174,16 @@ function mapAsyncIterable( > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >mapResult : (result: IteratorResult) => Promise> > : ^ ^^ ^^^^^ ->await iterator.return() : IteratorResult -> : ^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return() : Promise> -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.return : (value?: any) => Promise> -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->return : (value?: any) => Promise> -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>await iterator.return() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^ +>iterator.return() : Promise> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.return : (value?: R | PromiseLike | undefined) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>return : (value?: R | PromiseLike | undefined) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ : { value: undefined as any, done: true }; >{ value: undefined as any, done: true } : { value: any; done: true; } @@ -209,12 +209,12 @@ function mapAsyncIterable( > : ^^^^^^^ >typeof iterator.throw : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.throw : ((e?: any) => Promise>) | undefined -> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->throw : ((e?: any) => Promise>) | undefined -> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.throw : ((e?: any) => Promise>) | undefined +> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>throw : ((e?: any) => Promise>) | undefined +> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >"function" : "function" > : ^^^^^^^^^^ @@ -223,16 +223,16 @@ function mapAsyncIterable( > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >mapResult : (result: IteratorResult) => Promise> > : ^ ^^ ^^^^^ ->await iterator.throw(error) : IteratorResult -> : ^^^^^^^^^^^^^^^^^^^^^^ ->iterator.throw(error) : Promise> -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator.throw : (e?: any) => Promise> -> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->iterator : AsyncIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->throw : (e?: any) => Promise> -> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>await iterator.throw(error) : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^ +>iterator.throw(error) : Promise> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator.throw : (e?: any) => Promise> +> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>iterator : AsyncIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>throw : (e?: any) => Promise> +> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >error : unknown > : ^^^^^^^ } @@ -355,8 +355,8 @@ const doubles = mapAsyncIterable(iterable, (x) => x + x); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >mapAsyncIterable(iterable, (x) => x + x) : AsyncGenerator > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->mapAsyncIterable : (iterable: AsyncGenerator | AsyncIterable, callback: (value: T) => PromiseOrValue) => AsyncGenerator -> : ^ ^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>mapAsyncIterable : (iterable: AsyncGenerator | AsyncIterable, callback: (value: T) => PromiseOrValue) => AsyncGenerator +> : ^ ^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ >iterable : { [Symbol.asyncIterator](): any; next(): Promise<{ done: boolean; value: number; }>; } > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(x) => x + x : (x: number) => number diff --git a/tests/baselines/reference/emitArrowFunctionES6.types b/tests/baselines/reference/emitArrowFunctionES6.types index 472ea87102f67..3925aeeaf3766 100644 --- a/tests/baselines/reference/emitArrowFunctionES6.types +++ b/tests/baselines/reference/emitArrowFunctionES6.types @@ -79,10 +79,10 @@ var p1 = ([a]) => { }; > : ^^^ var p2 = ([...a]) => { }; ->p2 : ([...a]: Iterable) => void -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ->([...a]) => { } : ([...a]: Iterable) => void -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ +>p2 : ([...a]: Iterable) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>([...a]) => { } : ([...a]: Iterable) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >a : any[] > : ^^^^^ diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types index 4cc15fc48eeda..dc92b10c489ff 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types @@ -46,8 +46,8 @@ class C4 { > : ^^ async * f() { ->f : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types index 754591d94ba1f..42a23acadf4ed 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types @@ -46,8 +46,8 @@ class C4 { > : ^^ async * f() { ->f : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types index aa7bf57541199..93ea693423f50 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types @@ -46,8 +46,8 @@ class C4 { > : ^^ async * f() { ->f : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types index bfbf793fc22ca..d3f253300a53c 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types @@ -27,8 +27,8 @@ async function * f3() { } === F4.ts === async function * f4() { ->f4 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f4 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types index f44884810ae8c..c9e8a861c147e 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types @@ -27,8 +27,8 @@ async function * f3() { } === F4.ts === async function * f4() { ->f4 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f4 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types index d542e9bd52aaa..e9f6d8a5c12e3 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types @@ -27,8 +27,8 @@ async function * f3() { } === F4.ts === async function * f4() { ->f4 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f4 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types index c375fc5c0b7eb..385726d4ec892 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types @@ -33,10 +33,10 @@ const f3 = async function * () { } === F4.ts === const f4 = async function * () { ->f4 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { const x = yield* [1];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f4 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { const x = yield* [1];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types index 3072ee4edc5ff..074449e1ccf11 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types @@ -33,10 +33,10 @@ const f3 = async function * () { } === F4.ts === const f4 = async function * () { ->f4 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { const x = yield* [1];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f4 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { const x = yield* [1];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types index d48a16963a9eb..0e2315bd1ddc2 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types @@ -33,10 +33,10 @@ const f3 = async function * () { } === F4.ts === const f4 = async function * () { ->f4 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { const x = yield* [1];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f4 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { const x = yield* [1];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types index 604560f8a9d1f..58de2b68a6ca4 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types @@ -48,14 +48,14 @@ const o3 = { } === O4.ts === const o4 = { ->o4 : { f(): AsyncGenerator; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->{ async * f() { const x = yield* [1]; }} : { f(): AsyncGenerator; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>o4 : { f(): AsyncGenerator; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ async * f() { const x = yield* [1]; }} : { f(): AsyncGenerator; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ async * f() { ->f : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types index ead1acd6ef0d9..024281295e40d 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types @@ -48,14 +48,14 @@ const o3 = { } === O4.ts === const o4 = { ->o4 : { f(): AsyncGenerator; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->{ async * f() { const x = yield* [1]; }} : { f(): AsyncGenerator; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>o4 : { f(): AsyncGenerator; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ async * f() { const x = yield* [1]; }} : { f(): AsyncGenerator; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ async * f() { ->f : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types index c362f7b952b98..6bb7ecf62404c 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types @@ -48,14 +48,14 @@ const o3 = { } === O4.ts === const o4 = { ->o4 : { f(): AsyncGenerator; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->{ async * f() { const x = yield* [1]; }} : { f(): AsyncGenerator; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>o4 : { f(): AsyncGenerator; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ async * f() { const x = yield* [1]; }} : { f(): AsyncGenerator; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ async * f() { ->f : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x = yield* [1]; >x : any diff --git a/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types b/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types index 0b291230cde78..d53b79137fc27 100644 --- a/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types +++ b/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types @@ -436,8 +436,7 @@ export class IterableWeakMap implements WeakMap { > : ^ yield [key, value]; ->yield [key, value] : unknown -> : ^^^^^^^ +>yield [key, value] : any >[key, value] : [K, V] > : ^^^^^^ >key : K diff --git a/tests/baselines/reference/excessiveStackDepthFlatArray.types b/tests/baselines/reference/excessiveStackDepthFlatArray.types index d465f97fc02c5..6058609386027 100644 --- a/tests/baselines/reference/excessiveStackDepthFlatArray.types +++ b/tests/baselines/reference/excessiveStackDepthFlatArray.types @@ -1,7 +1,7 @@ //// [tests/cases/compiler/excessiveStackDepthFlatArray.ts] //// === Performance Stats === -Instantiation count: 1,000 +Instantiation count: 1,000 -> 2,500 === index.tsx === interface MiddlewareArray extends Array {} diff --git a/tests/baselines/reference/for-of29.errors.txt b/tests/baselines/reference/for-of29.errors.txt index 71a82303546df..f091e9dc9a694 100644 --- a/tests/baselines/reference/for-of29.errors.txt +++ b/tests/baselines/reference/for-of29.errors.txt @@ -1,4 +1,4 @@ -for-of29.ts(5,15): error TS2488: Type '{ [Symbol.iterator]?(): Iterator; }' must have a '[Symbol.iterator]()' method that returns an iterator. +for-of29.ts(5,15): error TS2488: Type '{ [Symbol.iterator]?(): Iterator; }' must have a '[Symbol.iterator]()' method that returns an iterator. ==== for-of29.ts (1 errors) ==== @@ -8,5 +8,5 @@ for-of29.ts(5,15): error TS2488: Type '{ [Symbol.iterator]?(): Iterator; }' must have a '[Symbol.iterator]()' method that returns an iterator. +!!! error TS2488: Type '{ [Symbol.iterator]?(): Iterator; }' must have a '[Symbol.iterator]()' method that returns an iterator. \ No newline at end of file diff --git a/tests/baselines/reference/generatorReturnTypeFallback.1.types b/tests/baselines/reference/generatorReturnTypeFallback.1.types index e15ee0e2669bd..fc04c48fbaf7c 100644 --- a/tests/baselines/reference/generatorReturnTypeFallback.1.types +++ b/tests/baselines/reference/generatorReturnTypeFallback.1.types @@ -3,8 +3,8 @@ === generatorReturnTypeFallback.1.ts === // Allow generators to fallback to IterableIterator if they do not need a type for the sent value while in strictNullChecks mode. function* f() { ->f : () => IterableIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield 1; >yield 1 : any diff --git a/tests/baselines/reference/generatorReturnTypeFallback.3.errors.txt b/tests/baselines/reference/generatorReturnTypeFallback.3.errors.txt deleted file mode 100644 index de2135daa6f7d..0000000000000 --- a/tests/baselines/reference/generatorReturnTypeFallback.3.errors.txt +++ /dev/null @@ -1,10 +0,0 @@ -error TS2318: Cannot find global type 'Generator'. - - -!!! error TS2318: Cannot find global type 'Generator'. -==== generatorReturnTypeFallback.3.ts (0 errors) ==== - // Do not allow generators to fallback to IterableIterator while in strictNullChecks mode if they need a type for the sent value. - // NOTE: In non-strictNullChecks mode, `undefined` (the default sent value) is assignable to everything. - function* f() { - const x: string = yield 1; - } \ No newline at end of file diff --git a/tests/baselines/reference/generatorReturnTypeFallback.3.symbols b/tests/baselines/reference/generatorReturnTypeFallback.3.symbols index 41d807d743be1..ce94c240f0c16 100644 --- a/tests/baselines/reference/generatorReturnTypeFallback.3.symbols +++ b/tests/baselines/reference/generatorReturnTypeFallback.3.symbols @@ -1,11 +1,9 @@ //// [tests/cases/conformance/generators/generatorReturnTypeFallback.3.ts] //// === generatorReturnTypeFallback.3.ts === -// Do not allow generators to fallback to IterableIterator while in strictNullChecks mode if they need a type for the sent value. -// NOTE: In non-strictNullChecks mode, `undefined` (the default sent value) is assignable to everything. function* f() { >f : Symbol(f, Decl(generatorReturnTypeFallback.3.ts, 0, 0)) const x: string = yield 1; ->x : Symbol(x, Decl(generatorReturnTypeFallback.3.ts, 3, 9)) +>x : Symbol(x, Decl(generatorReturnTypeFallback.3.ts, 1, 9)) } diff --git a/tests/baselines/reference/generatorReturnTypeFallback.3.types b/tests/baselines/reference/generatorReturnTypeFallback.3.types index 54c5039049bea..2bc88213fc3fa 100644 --- a/tests/baselines/reference/generatorReturnTypeFallback.3.types +++ b/tests/baselines/reference/generatorReturnTypeFallback.3.types @@ -1,17 +1,14 @@ //// [tests/cases/conformance/generators/generatorReturnTypeFallback.3.ts] //// === generatorReturnTypeFallback.3.ts === -// Do not allow generators to fallback to IterableIterator while in strictNullChecks mode if they need a type for the sent value. -// NOTE: In non-strictNullChecks mode, `undefined` (the default sent value) is assignable to everything. function* f() { ->f : () => {} -> : ^^^^^^^^ +>f : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x: string = yield 1; >x : string > : ^^^^^^ >yield 1 : any -> : ^^^ >1 : 1 > : ^ } diff --git a/tests/baselines/reference/generatorReturnTypeFallback.4.types b/tests/baselines/reference/generatorReturnTypeFallback.4.types index acd098251ee9d..eb3fbef238dce 100644 --- a/tests/baselines/reference/generatorReturnTypeFallback.4.types +++ b/tests/baselines/reference/generatorReturnTypeFallback.4.types @@ -4,8 +4,8 @@ // Allow generators to fallback to IterableIterator if they are not in strictNullChecks mode // NOTE: In non-strictNullChecks mode, `undefined` (the default sent value) is assignable to everything. function* f() { ->f : () => IterableIterator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const x: string = yield 1; >x : string diff --git a/tests/baselines/reference/generatorReturnTypeFallback.5.types b/tests/baselines/reference/generatorReturnTypeFallback.5.types index 7d85ccb1af79c..a3eab2c4e3bd2 100644 --- a/tests/baselines/reference/generatorReturnTypeFallback.5.types +++ b/tests/baselines/reference/generatorReturnTypeFallback.5.types @@ -7,8 +7,7 @@ function* f(): IterableIterator { > : ^^^^^^ yield 1; ->yield 1 : undefined -> : ^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ } diff --git a/tests/baselines/reference/generatorReturnTypeInference.types b/tests/baselines/reference/generatorReturnTypeInference.types index a2ad28e5e30a1..e6249102d6437 100644 --- a/tests/baselines/reference/generatorReturnTypeInference.types +++ b/tests/baselines/reference/generatorReturnTypeInference.types @@ -40,8 +40,8 @@ function* g002() { // Generator } function* g003() { // Generator ->g003 : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>g003 : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* []; >yield* [] : any @@ -51,8 +51,8 @@ function* g003() { // Generator } function* g004() { // Generator ->g004 : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>g004 : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* iterableIterator; >yield* iterableIterator : any diff --git a/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.types b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.types index f52fb7eaeb022..03155f5fd2b4e 100644 --- a/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.types +++ b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.types @@ -40,8 +40,8 @@ function* g002() { // Generator } function* g003() { // Generator ->g003 : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>g003 : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ // NOTE: In strict mode, `[]` produces the type `never[]`. // In non-strict mode, `[]` produces the type `undefined[]` which is implicitly any. @@ -53,8 +53,8 @@ function* g003() { // Generator } function* g004() { // Generator ->g004 : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>g004 : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* iterableIterator; >yield* iterableIterator : any diff --git a/tests/baselines/reference/generatorTypeCheck11.js b/tests/baselines/reference/generatorTypeCheck11.js index 09d30ea001b3d..7d9b616a264b2 100644 --- a/tests/baselines/reference/generatorTypeCheck11.js +++ b/tests/baselines/reference/generatorTypeCheck11.js @@ -1,7 +1,7 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts] //// //// [generatorTypeCheck11.ts] -function* g(): IterableIterator { +function* g(): IterableIterator { return 0; } diff --git a/tests/baselines/reference/generatorTypeCheck11.symbols b/tests/baselines/reference/generatorTypeCheck11.symbols index f5f3ce3fdde53..44a4c4d62310e 100644 --- a/tests/baselines/reference/generatorTypeCheck11.symbols +++ b/tests/baselines/reference/generatorTypeCheck11.symbols @@ -1,7 +1,7 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts] //// === generatorTypeCheck11.ts === -function* g(): IterableIterator { +function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck11.ts, 0, 0)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) diff --git a/tests/baselines/reference/generatorTypeCheck11.types b/tests/baselines/reference/generatorTypeCheck11.types index dda8baa38dc4a..b1788b17a91db 100644 --- a/tests/baselines/reference/generatorTypeCheck11.types +++ b/tests/baselines/reference/generatorTypeCheck11.types @@ -1,9 +1,9 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts] //// === generatorTypeCheck11.ts === -function* g(): IterableIterator { ->g : () => IterableIterator -> : ^^^^^^ +function* g(): IterableIterator { +>g : () => IterableIterator +> : ^^^^^^ return 0; >0 : 0 diff --git a/tests/baselines/reference/generatorTypeCheck12.js b/tests/baselines/reference/generatorTypeCheck12.js index 5ea3a5e9a7ee2..4acc1e520580b 100644 --- a/tests/baselines/reference/generatorTypeCheck12.js +++ b/tests/baselines/reference/generatorTypeCheck12.js @@ -1,7 +1,7 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts] //// //// [generatorTypeCheck12.ts] -function* g(): IterableIterator { +function* g(): IterableIterator { return ""; } diff --git a/tests/baselines/reference/generatorTypeCheck12.symbols b/tests/baselines/reference/generatorTypeCheck12.symbols index 8fd6746b19d2a..d66acfb2ace76 100644 --- a/tests/baselines/reference/generatorTypeCheck12.symbols +++ b/tests/baselines/reference/generatorTypeCheck12.symbols @@ -1,7 +1,7 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts] //// === generatorTypeCheck12.ts === -function* g(): IterableIterator { +function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck12.ts, 0, 0)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) diff --git a/tests/baselines/reference/generatorTypeCheck12.types b/tests/baselines/reference/generatorTypeCheck12.types index 407f05e6f391c..4a55e92a7d1aa 100644 --- a/tests/baselines/reference/generatorTypeCheck12.types +++ b/tests/baselines/reference/generatorTypeCheck12.types @@ -1,9 +1,9 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts] //// === generatorTypeCheck12.ts === -function* g(): IterableIterator { ->g : () => IterableIterator -> : ^^^^^^ +function* g(): IterableIterator { +>g : () => IterableIterator +> : ^^^^^^ return ""; >"" : "" diff --git a/tests/baselines/reference/generatorTypeCheck13.js b/tests/baselines/reference/generatorTypeCheck13.js index 1a743854ab2da..a447f44ea86ae 100644 --- a/tests/baselines/reference/generatorTypeCheck13.js +++ b/tests/baselines/reference/generatorTypeCheck13.js @@ -1,7 +1,7 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts] //// //// [generatorTypeCheck13.ts] -function* g(): IterableIterator { +function* g(): IterableIterator { yield 0; return ""; } diff --git a/tests/baselines/reference/generatorTypeCheck13.symbols b/tests/baselines/reference/generatorTypeCheck13.symbols index e2a80949d6c1d..71557b215c836 100644 --- a/tests/baselines/reference/generatorTypeCheck13.symbols +++ b/tests/baselines/reference/generatorTypeCheck13.symbols @@ -1,7 +1,7 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts] //// === generatorTypeCheck13.ts === -function* g(): IterableIterator { +function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck13.ts, 0, 0)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) diff --git a/tests/baselines/reference/generatorTypeCheck13.types b/tests/baselines/reference/generatorTypeCheck13.types index 85f6e91aefdd9..6144546acc248 100644 --- a/tests/baselines/reference/generatorTypeCheck13.types +++ b/tests/baselines/reference/generatorTypeCheck13.types @@ -1,13 +1,12 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts] //// === generatorTypeCheck13.ts === -function* g(): IterableIterator { ->g : () => IterableIterator -> : ^^^^^^ +function* g(): IterableIterator { +>g : () => IterableIterator +> : ^^^^^^ yield 0; ->yield 0 : undefined -> : ^^^^^^^^^ +>yield 0 : any >0 : 0 > : ^ diff --git a/tests/baselines/reference/generatorTypeCheck17.types b/tests/baselines/reference/generatorTypeCheck17.types index f163aad700ceb..4f10af02fab72 100644 --- a/tests/baselines/reference/generatorTypeCheck17.types +++ b/tests/baselines/reference/generatorTypeCheck17.types @@ -20,12 +20,10 @@ function* g(): IterableIterator { > : ^^^^^^ yield; ->yield : undefined -> : ^^^^^^^^^ +>yield : any yield new Bar; ->yield new Bar : undefined -> : ^^^^^^^^^ +>yield new Bar : any >new Bar : Bar > : ^^^ >Bar : typeof Bar diff --git a/tests/baselines/reference/generatorTypeCheck18.types b/tests/baselines/reference/generatorTypeCheck18.types index d9c9694e47213..a7d2eca6795f2 100644 --- a/tests/baselines/reference/generatorTypeCheck18.types +++ b/tests/baselines/reference/generatorTypeCheck18.types @@ -18,12 +18,12 @@ function* g(): IterableIterator { > : ^^^^^^ yield; ->yield : undefined -> : ^^^^^^^^^ +>yield : any +> : ^^^ yield new Baz; ->yield new Baz : undefined -> : ^^^^^^^^^ +>yield new Baz : any +> : ^^^ >new Baz : Baz > : ^^^ >Baz : typeof Baz diff --git a/tests/baselines/reference/generatorTypeCheck19.types b/tests/baselines/reference/generatorTypeCheck19.types index 9faf23c7ad3ce..b25b28b31670b 100644 --- a/tests/baselines/reference/generatorTypeCheck19.types +++ b/tests/baselines/reference/generatorTypeCheck19.types @@ -20,8 +20,7 @@ function* g(): IterableIterator { > : ^^^^^^ yield; ->yield : undefined -> : ^^^^^^^^^ +>yield : any yield * [new Bar]; >yield * [new Bar] : any diff --git a/tests/baselines/reference/generatorTypeCheck20.types b/tests/baselines/reference/generatorTypeCheck20.types index 243a849924d61..469c7036bbefb 100644 --- a/tests/baselines/reference/generatorTypeCheck20.types +++ b/tests/baselines/reference/generatorTypeCheck20.types @@ -18,8 +18,8 @@ function* g(): IterableIterator { > : ^^^^^^ yield; ->yield : undefined -> : ^^^^^^^^^ +>yield : any +> : ^^^ yield * [new Baz]; >yield * [new Baz] : any diff --git a/tests/baselines/reference/generatorTypeCheck21.types b/tests/baselines/reference/generatorTypeCheck21.types index 58cc46f34578e..55f2d96377a23 100644 --- a/tests/baselines/reference/generatorTypeCheck21.types +++ b/tests/baselines/reference/generatorTypeCheck21.types @@ -20,8 +20,8 @@ function* g(): IterableIterator { > : ^^^^^^ yield; ->yield : undefined -> : ^^^^^^^^^ +>yield : any +> : ^^^ yield * new Bar; >yield * new Bar : any diff --git a/tests/baselines/reference/generatorTypeCheck22.types b/tests/baselines/reference/generatorTypeCheck22.types index 73246839319ed..f8f6580b45433 100644 --- a/tests/baselines/reference/generatorTypeCheck22.types +++ b/tests/baselines/reference/generatorTypeCheck22.types @@ -22,8 +22,8 @@ class Baz { z: number } > : ^^^^^^ function* g3() { ->g3 : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>g3 : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield; >yield : any diff --git a/tests/baselines/reference/generatorTypeCheck23.types b/tests/baselines/reference/generatorTypeCheck23.types index 52056e44274b5..50e76794cc437 100644 --- a/tests/baselines/reference/generatorTypeCheck23.types +++ b/tests/baselines/reference/generatorTypeCheck23.types @@ -22,8 +22,8 @@ class Baz { z: number } > : ^^^^^^ function* g3() { ->g3 : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>g3 : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield; >yield : any diff --git a/tests/baselines/reference/generatorTypeCheck24.types b/tests/baselines/reference/generatorTypeCheck24.types index 0f243defbf3b6..d0869e1134889 100644 --- a/tests/baselines/reference/generatorTypeCheck24.types +++ b/tests/baselines/reference/generatorTypeCheck24.types @@ -22,8 +22,8 @@ class Baz { z: number } > : ^^^^^^ function* g3() { ->g3 : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>g3 : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield; >yield : any diff --git a/tests/baselines/reference/generatorTypeCheck25.errors.txt b/tests/baselines/reference/generatorTypeCheck25.errors.txt index ab28ce3ace486..2113fedd55fd5 100644 --- a/tests/baselines/reference/generatorTypeCheck25.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck25.errors.txt @@ -1,5 +1,5 @@ -generatorTypeCheck25.ts(4,5): error TS2322: Type '() => Generator' is not assignable to type '() => Iterable'. - Call signature return types 'Generator' and 'Iterable' are incompatible. +generatorTypeCheck25.ts(4,5): error TS2322: Type '() => Generator' is not assignable to type '() => Iterable'. + Call signature return types 'Generator' and 'Iterable' are incompatible. The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. @@ -14,8 +14,8 @@ generatorTypeCheck25.ts(4,5): error TS2322: Type '() => Generator Iterable = function* () { ~~ -!!! error TS2322: Type '() => Generator' is not assignable to type '() => Iterable'. -!!! error TS2322: Call signature return types 'Generator' and 'Iterable' are incompatible. +!!! error TS2322: Type '() => Generator' is not assignable to type '() => Iterable'. +!!! error TS2322: Call signature return types 'Generator' and 'Iterable' are incompatible. !!! error TS2322: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. !!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. !!! error TS2322: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. diff --git a/tests/baselines/reference/generatorTypeCheck25.types b/tests/baselines/reference/generatorTypeCheck25.types index 21c909b1895c5..322bb4b92688c 100644 --- a/tests/baselines/reference/generatorTypeCheck25.types +++ b/tests/baselines/reference/generatorTypeCheck25.types @@ -24,24 +24,24 @@ class Baz { z: number } var g3: () => Iterable = function* () { >g3 : () => Iterable > : ^^^^^^ ->function* () { yield; yield new Bar; yield new Baz; yield *[new Bar]; yield *[new Baz];} : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* () { yield; yield new Bar; yield new Baz; yield *[new Bar]; yield *[new Baz];} : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield; ->yield : undefined -> : ^^^^^^^^^ +>yield : any +> : ^^^ yield new Bar; ->yield new Bar : undefined -> : ^^^^^^^^^ +>yield new Bar : any +> : ^^^ >new Bar : Bar > : ^^^ >Bar : typeof Bar > : ^^^^^^^^^^ yield new Baz; ->yield new Baz : undefined -> : ^^^^^^^^^ +>yield new Baz : any +> : ^^^ >new Baz : Baz > : ^^^ >Baz : typeof Baz diff --git a/tests/baselines/reference/generatorTypeCheck26.js b/tests/baselines/reference/generatorTypeCheck26.js index 5bb74d893adcf..5004a9aa05223 100644 --- a/tests/baselines/reference/generatorTypeCheck26.js +++ b/tests/baselines/reference/generatorTypeCheck26.js @@ -1,7 +1,7 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts] //// //// [generatorTypeCheck26.ts] -function* g(): IterableIterator<(x: string) => number> { +function* g(): IterableIterator<(x: string) => number, (x: string) => number> { yield x => x.length; yield *[x => x.length]; return x => x.length; diff --git a/tests/baselines/reference/generatorTypeCheck26.symbols b/tests/baselines/reference/generatorTypeCheck26.symbols index c625c5fda15a2..3bc5d87349097 100644 --- a/tests/baselines/reference/generatorTypeCheck26.symbols +++ b/tests/baselines/reference/generatorTypeCheck26.symbols @@ -1,10 +1,11 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts] //// === generatorTypeCheck26.ts === -function* g(): IterableIterator<(x: string) => number> { +function* g(): IterableIterator<(x: string) => number, (x: string) => number> { >g : Symbol(g, Decl(generatorTypeCheck26.ts, 0, 0)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck26.ts, 0, 33)) +>x : Symbol(x, Decl(generatorTypeCheck26.ts, 0, 56)) yield x => x.length; >x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9)) @@ -20,5 +21,7 @@ function* g(): IterableIterator<(x: string) => number> { return x => x.length; >x : Symbol(x, Decl(generatorTypeCheck26.ts, 3, 10)) +>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck26.ts, 3, 10)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) } diff --git a/tests/baselines/reference/generatorTypeCheck26.types b/tests/baselines/reference/generatorTypeCheck26.types index 013714b09580d..7f75848a3357d 100644 --- a/tests/baselines/reference/generatorTypeCheck26.types +++ b/tests/baselines/reference/generatorTypeCheck26.types @@ -1,15 +1,16 @@ //// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts] //// === generatorTypeCheck26.ts === -function* g(): IterableIterator<(x: string) => number> { ->g : () => IterableIterator<(x: string) => number> -> : ^^^^^^ +function* g(): IterableIterator<(x: string) => number, (x: string) => number> { +>g : () => IterableIterator<(x: string) => number, (x: string) => number> +> : ^^^^^^ +>x : string +> : ^^^^^^ >x : string > : ^^^^^^ yield x => x.length; ->yield x => x.length : undefined -> : ^^^^^^^^^ +>yield x => x.length : any >x => x.length : (x: string) => number > : ^ ^^^^^^^^^^^^^^^^^^^ >x : string @@ -37,12 +38,14 @@ function* g(): IterableIterator<(x: string) => number> { > : ^^^^^^ return x => x.length; ->x => x.length : (x: any) => any -> : ^ ^^^^^^^^^^^^^ ->x : any ->x.length : any ->x : any -> : ^^^ ->length : any -> : ^^^ +>x => x.length : (x: string) => number +> : ^ ^^^^^^^^^^^^^^^^^^^ +>x : string +> : ^^^^^^ +>x.length : number +> : ^^^^^^ +>x : string +> : ^^^^^^ +>length : number +> : ^^^^^^ } diff --git a/tests/baselines/reference/generatorTypeCheck27.types b/tests/baselines/reference/generatorTypeCheck27.types index 407ed12838649..fabc419cdbfad 100644 --- a/tests/baselines/reference/generatorTypeCheck27.types +++ b/tests/baselines/reference/generatorTypeCheck27.types @@ -10,14 +10,13 @@ function* g(): IterableIterator<(x: string) => number> { yield * function* () { >yield * function* () { yield x => x.length; } () : void > : ^^^^ ->function* () { yield x => x.length; } () : Generator<(x: string) => number, void, undefined> -> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->function* () { yield x => x.length; } : () => Generator<(x: string) => number, void, undefined> -> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* () { yield x => x.length; } () : Generator<(x: string) => number, void, any> +> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* () { yield x => x.length; } : () => Generator<(x: string) => number, void, any> +> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield x => x.length; ->yield x => x.length : undefined -> : ^^^^^^^^^ +>yield x => x.length : any >x => x.length : (x: string) => number > : ^ ^^^^^^^^^^^^^^^^^^^ >x : string diff --git a/tests/baselines/reference/generatorTypeCheck28.types b/tests/baselines/reference/generatorTypeCheck28.types index c7675a7248536..be2015e367105 100644 --- a/tests/baselines/reference/generatorTypeCheck28.types +++ b/tests/baselines/reference/generatorTypeCheck28.types @@ -10,12 +10,12 @@ function* g(): IterableIterator<(x: string) => number> { yield * { >yield * { *[Symbol.iterator]() { yield x => x.length; } } : void > : ^^^^ ->{ *[Symbol.iterator]() { yield x => x.length; } } : { [Symbol.iterator](): Generator<(x: string) => number, void, undefined>; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ *[Symbol.iterator]() { yield x => x.length; } } : { [Symbol.iterator](): Generator<(x: string) => number, void, any>; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ *[Symbol.iterator]() { ->[Symbol.iterator] : () => Generator<(x: string) => number, void, undefined> -> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.iterator] : () => Generator<(x: string) => number, void, any> +> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Symbol.iterator : unique symbol > : ^^^^^^^^^^^^^ >Symbol : SymbolConstructor @@ -24,8 +24,7 @@ function* g(): IterableIterator<(x: string) => number> { > : ^^^^^^^^^^^^^ yield x => x.length; ->yield x => x.length : undefined -> : ^^^^^^^^^ +>yield x => x.length : any >x => x.length : (x: string) => number > : ^ ^^^^^^^^^^^^^^^^^^^ >x : string diff --git a/tests/baselines/reference/generatorTypeCheck29.types b/tests/baselines/reference/generatorTypeCheck29.types index c8420f3d22938..2056a0db6323b 100644 --- a/tests/baselines/reference/generatorTypeCheck29.types +++ b/tests/baselines/reference/generatorTypeCheck29.types @@ -8,16 +8,14 @@ function* g2(): Iterator number>> { > : ^^^^^^ yield function* () { ->yield function* () { yield x => x.length; } () : undefined -> : ^^^^^^^^^ ->function* () { yield x => x.length; } () : Generator<(x: string) => number, void, undefined> -> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->function* () { yield x => x.length; } : () => Generator<(x: string) => number, void, undefined> -> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield function* () { yield x => x.length; } () : any +>function* () { yield x => x.length; } () : Generator<(x: string) => number, void, any> +> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* () { yield x => x.length; } : () => Generator<(x: string) => number, void, any> +> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield x => x.length; ->yield x => x.length : undefined -> : ^^^^^^^^^ +>yield x => x.length : any >x => x.length : (x: string) => number > : ^ ^^^^^^^^^^^^^^^^^^^ >x : string diff --git a/tests/baselines/reference/generatorTypeCheck30.types b/tests/baselines/reference/generatorTypeCheck30.types index bbb0e9be9f6dd..dacc0a2b8bc25 100644 --- a/tests/baselines/reference/generatorTypeCheck30.types +++ b/tests/baselines/reference/generatorTypeCheck30.types @@ -8,16 +8,14 @@ function* g2(): Iterator number>> { > : ^^^^^^ yield function* () { ->yield function* () { yield x => x.length; } () : undefined -> : ^^^^^^^^^ ->function* () { yield x => x.length; } () : Generator<(x: string) => number, void, undefined> -> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->function* () { yield x => x.length; } : () => Generator<(x: string) => number, void, undefined> -> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield function* () { yield x => x.length; } () : any +>function* () { yield x => x.length; } () : Generator<(x: string) => number, void, any> +> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* () { yield x => x.length; } : () => Generator<(x: string) => number, void, any> +> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield x => x.length; ->yield x => x.length : undefined -> : ^^^^^^^^^ +>yield x => x.length : any >x => x.length : (x: string) => number > : ^ ^^^^^^^^^^^^^^^^^^^ >x : string diff --git a/tests/baselines/reference/generatorTypeCheck31.types b/tests/baselines/reference/generatorTypeCheck31.types index 18130e17dfa3c..9bbb95c88d2cb 100644 --- a/tests/baselines/reference/generatorTypeCheck31.types +++ b/tests/baselines/reference/generatorTypeCheck31.types @@ -8,8 +8,8 @@ function* g2(): Iterator<() => Iterable<(x: string) => number>> { > : ^^^^^^ yield function* () { ->yield function* () { yield x => x.length; } () : undefined -> : ^^^^^^^^^ +>yield function* () { yield x => x.length; } () : any +> : ^^^ >function* () { yield x => x.length; } () : Generator<(x: any) => any, void, unknown> > : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >function* () { yield x => x.length; } : () => Generator<(x: any) => any, void, unknown> diff --git a/tests/baselines/reference/generatorTypeCheck45.types b/tests/baselines/reference/generatorTypeCheck45.types index d8577d007c9f7..edb905d1866a0 100644 --- a/tests/baselines/reference/generatorTypeCheck45.types +++ b/tests/baselines/reference/generatorTypeCheck45.types @@ -22,10 +22,9 @@ foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, sh > : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ >"" : "" > : ^^ ->function* () { yield x => x.length } : () => Generator<(x: string) => number, void, undefined> -> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield x => x.length : undefined -> : ^^^^^^^^^ +>function* () { yield x => x.length } : () => Generator<(x: string) => number, void, any> +> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield x => x.length : any >x => x.length : (x: string) => number > : ^ ^^^^^^^^^^^^^^^^^^^ >x : string diff --git a/tests/baselines/reference/generatorTypeCheck46.types b/tests/baselines/reference/generatorTypeCheck46.types index 681fe2cb930c8..ee34af45e0b17 100644 --- a/tests/baselines/reference/generatorTypeCheck46.types +++ b/tests/baselines/reference/generatorTypeCheck46.types @@ -22,18 +22,18 @@ foo("", function* () { > : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ >"" : "" > : ^^ ->function* () { yield* { *[Symbol.iterator]() { yield x => x.length } }} : () => Generator<(x: string) => number, void, undefined> -> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* () { yield* { *[Symbol.iterator]() { yield x => x.length } }} : () => Generator<(x: string) => number, void, any> +> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* { >yield* { *[Symbol.iterator]() { yield x => x.length } } : void > : ^^^^ ->{ *[Symbol.iterator]() { yield x => x.length } } : { [Symbol.iterator](): Generator<(x: string) => number, void, undefined>; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ *[Symbol.iterator]() { yield x => x.length } } : { [Symbol.iterator](): Generator<(x: string) => number, void, any>; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ *[Symbol.iterator]() { ->[Symbol.iterator] : () => Generator<(x: string) => number, void, undefined> -> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.iterator] : () => Generator<(x: string) => number, void, any> +> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Symbol.iterator : unique symbol > : ^^^^^^^^^^^^^ >Symbol : SymbolConstructor @@ -42,8 +42,7 @@ foo("", function* () { > : ^^^^^^^^^^^^^ yield x => x.length ->yield x => x.length : undefined -> : ^^^^^^^^^ +>yield x => x.length : any >x => x.length : (x: string) => number > : ^ ^^^^^^^^^^^^^^^^^^^ >x : string diff --git a/tests/baselines/reference/generatorTypeCheck53.types b/tests/baselines/reference/generatorTypeCheck53.types index 139ca5904a94b..308c3c45f0e42 100644 --- a/tests/baselines/reference/generatorTypeCheck53.types +++ b/tests/baselines/reference/generatorTypeCheck53.types @@ -14,8 +14,8 @@ class Baz { z: number } > : ^^^^^^ function* g() { ->g : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>g : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield new Foo; >yield new Foo : any diff --git a/tests/baselines/reference/generatorTypeCheck54.types b/tests/baselines/reference/generatorTypeCheck54.types index 0bb7b4e37d61c..3162d1537f12c 100644 --- a/tests/baselines/reference/generatorTypeCheck54.types +++ b/tests/baselines/reference/generatorTypeCheck54.types @@ -14,8 +14,8 @@ class Baz { z: number } > : ^^^^^^ function* g() { ->g : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>g : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* [new Foo]; >yield* [new Foo] : any diff --git a/tests/baselines/reference/generatorTypeCheck62.errors.txt b/tests/baselines/reference/generatorTypeCheck62.errors.txt new file mode 100644 index 0000000000000..6599e8fdd0109 --- /dev/null +++ b/tests/baselines/reference/generatorTypeCheck62.errors.txt @@ -0,0 +1,69 @@ +generatorTypeCheck62.ts(24,62): error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: State) => IterableIterator'. + Call signature return types 'Generator' and 'IterableIterator' are incompatible. + The types returned by 'next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult'. + Type 'IteratorReturnResult' is not assignable to type 'IteratorResult'. + Type 'IteratorReturnResult' is not assignable to type 'IteratorReturnResult'. + Type 'State' is not assignable to type 'void'. +generatorTypeCheck62.ts(32,62): error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: any) => IterableIterator'. + Call signature return types 'Generator' and 'IterableIterator' are incompatible. + The types returned by 'next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult'. + Type 'IteratorReturnResult' is not assignable to type 'IteratorResult'. + Type 'IteratorReturnResult' is not assignable to type 'IteratorReturnResult'. + Type 'State' is not assignable to type 'void'. + + +==== generatorTypeCheck62.ts (2 errors) ==== + export interface StrategicState { + lastStrategyApplied?: string; + } + + export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { + return function*(state) { + for (const next of gen(state)) { + if (next) { + next.lastStrategyApplied = stratName; + } + yield next; + } + } + } + + export interface Strategy { + (a: T): IterableIterator; + } + + export interface State extends StrategicState { + foo: number; + } + + export const Nothing1: Strategy = strategy("Nothing", function*(state: State) { + ~~~~~~~~ +!!! error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: State) => IterableIterator'. +!!! error TS2345: Call signature return types 'Generator' and 'IterableIterator' are incompatible. +!!! error TS2345: The types returned by 'next(...)' are incompatible between these types. +!!! error TS2345: Type 'IteratorResult' is not assignable to type 'IteratorResult'. +!!! error TS2345: Type 'IteratorReturnResult' is not assignable to type 'IteratorResult'. +!!! error TS2345: Type 'IteratorReturnResult' is not assignable to type 'IteratorReturnResult'. +!!! error TS2345: Type 'State' is not assignable to type 'void'. + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. + }); + + export const Nothing2: Strategy = strategy("Nothing", function*(state: State) { + yield state; + }); + + export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { + ~~~~~~~~ +!!! error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: any) => IterableIterator'. +!!! error TS2345: Call signature return types 'Generator' and 'IterableIterator' are incompatible. +!!! error TS2345: The types returned by 'next(...)' are incompatible between these types. +!!! error TS2345: Type 'IteratorResult' is not assignable to type 'IteratorResult'. +!!! error TS2345: Type 'IteratorReturnResult' is not assignable to type 'IteratorResult'. +!!! error TS2345: Type 'IteratorReturnResult' is not assignable to type 'IteratorReturnResult'. +!!! error TS2345: Type 'State' is not assignable to type 'void'. + yield ; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. + }); + \ No newline at end of file diff --git a/tests/baselines/reference/generatorTypeCheck62.js b/tests/baselines/reference/generatorTypeCheck62.js index 9ca8500b6f1bb..b07e7b95dd9f4 100644 --- a/tests/baselines/reference/generatorTypeCheck62.js +++ b/tests/baselines/reference/generatorTypeCheck62.js @@ -5,7 +5,7 @@ export interface StrategicState { lastStrategyApplied?: string; } -export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { +export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { return function*(state) { for (const next of gen(state)) { if (next) { @@ -17,7 +17,7 @@ export function strategy(stratName: string, gen: (a: T } export interface Strategy { - (a: T): IterableIterator; + (a: T): IterableIterator; } export interface State extends StrategicState { @@ -25,7 +25,7 @@ export interface State extends StrategicState { } export const Nothing1: Strategy = strategy("Nothing", function*(state: State) { - return state; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); export const Nothing2: Strategy = strategy("Nothing", function*(state: State) { @@ -34,7 +34,7 @@ export const Nothing2: Strategy = strategy("Nothing", function*(state: St export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { yield ; - return state; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); @@ -54,12 +54,12 @@ function strategy(stratName, gen) { }; } exports.Nothing1 = strategy("Nothing", function* (state) { - return state; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); exports.Nothing2 = strategy("Nothing", function* (state) { yield state; }); exports.Nothing3 = strategy("Nothing", function* (state) { yield; - return state; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); diff --git a/tests/baselines/reference/generatorTypeCheck62.symbols b/tests/baselines/reference/generatorTypeCheck62.symbols index 025a0b5277ef5..ba66910de74e7 100644 --- a/tests/baselines/reference/generatorTypeCheck62.symbols +++ b/tests/baselines/reference/generatorTypeCheck62.symbols @@ -8,7 +8,7 @@ export interface StrategicState { >lastStrategyApplied : Symbol(StrategicState.lastStrategyApplied, Decl(generatorTypeCheck62.ts, 0, 33)) } -export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { +export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { >strategy : Symbol(strategy, Decl(generatorTypeCheck62.ts, 2, 1)) >T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25)) >StrategicState : Symbol(StrategicState, Decl(generatorTypeCheck62.ts, 0, 0)) @@ -18,7 +18,7 @@ export function strategy(stratName: string, gen: (a: T >T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) >T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25)) ->a : Symbol(a, Decl(generatorTypeCheck62.ts, 4, 120)) +>a : Symbol(a, Decl(generatorTypeCheck62.ts, 4, 126)) >T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) >T : Symbol(T, Decl(generatorTypeCheck62.ts, 4, 25)) @@ -50,7 +50,7 @@ export interface Strategy { >Strategy : Symbol(Strategy, Decl(generatorTypeCheck62.ts, 13, 1)) >T : Symbol(T, Decl(generatorTypeCheck62.ts, 15, 26)) - (a: T): IterableIterator; + (a: T): IterableIterator; >a : Symbol(a, Decl(generatorTypeCheck62.ts, 16, 5)) >T : Symbol(T, Decl(generatorTypeCheck62.ts, 15, 26)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) @@ -73,7 +73,7 @@ export const Nothing1: Strategy = strategy("Nothing", function*(state: St >state : Symbol(state, Decl(generatorTypeCheck62.ts, 23, 71)) >State : Symbol(State, Decl(generatorTypeCheck62.ts, 17, 1)) - return state; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. >state : Symbol(state, Decl(generatorTypeCheck62.ts, 23, 71)) }); @@ -100,7 +100,7 @@ export const Nothing3: Strategy = strategy("Nothing", function* (state: S >State : Symbol(State, Decl(generatorTypeCheck62.ts, 17, 1)) yield ; - return state; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. >state : Symbol(state, Decl(generatorTypeCheck62.ts, 31, 72)) }); diff --git a/tests/baselines/reference/generatorTypeCheck62.types b/tests/baselines/reference/generatorTypeCheck62.types index 6cf1b381d66f9..6196ace757ddb 100644 --- a/tests/baselines/reference/generatorTypeCheck62.types +++ b/tests/baselines/reference/generatorTypeCheck62.types @@ -7,31 +7,31 @@ export interface StrategicState { > : ^^^^^^ } -export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { ->strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { +>strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ >stratName : string > : ^^^^^^ ->gen : (a: T) => IterableIterator -> : ^ ^^ ^^^^^ +>gen : (a: T) => IterableIterator +> : ^ ^^ ^^^^^ >a : T > : ^ >a : T > : ^ return function*(state) { ->function*(state) { for (const next of gen(state)) { if (next) { next.lastStrategyApplied = stratName; } yield next; } } : (state: T) => Generator -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function*(state) { for (const next of gen(state)) { if (next) { next.lastStrategyApplied = stratName; } yield next; } } : (state: T) => Generator +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >state : T > : ^ for (const next of gen(state)) { >next : T > : ^ ->gen(state) : IterableIterator -> : ^^^^^^^^^^^^^^^^^^^ ->gen : (a: T) => IterableIterator -> : ^ ^^ ^^^^^ +>gen(state) : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>gen : (a: T) => IterableIterator +> : ^ ^^ ^^^^^ >state : T > : ^ @@ -52,8 +52,8 @@ export function strategy(stratName: string, gen: (a: T > : ^^^^^^ } yield next; ->yield next : undefined -> : ^^^^^^^^^ +>yield next : any +> : ^^^ >next : T > : ^ } @@ -61,7 +61,7 @@ export function strategy(stratName: string, gen: (a: T } export interface Strategy { - (a: T): IterableIterator; + (a: T): IterableIterator; >a : T > : ^ } @@ -75,18 +75,18 @@ export interface State extends StrategicState { export const Nothing1: Strategy = strategy("Nothing", function*(state: State) { >Nothing1 : Strategy > : ^^^^^^^^^^^^^^^ ->strategy("Nothing", function*(state: State) { return state;}) : (a: State) => IterableIterator -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>strategy("Nothing", function*(state: State) { return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: State) => IterableIterator +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ >"Nothing" : "Nothing" > : ^^^^^^^^^ ->function*(state: State) { return state;} : (state: State) => Generator -> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function*(state: State) { return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.} : (state: State) => Generator +> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >state : State > : ^^^^^ - return state; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. >state : State > : ^^^^^ @@ -95,20 +95,20 @@ export const Nothing1: Strategy = strategy("Nothing", function*(state: St export const Nothing2: Strategy = strategy("Nothing", function*(state: State) { >Nothing2 : Strategy > : ^^^^^^^^^^^^^^^ ->strategy("Nothing", function*(state: State) { yield state;}) : (a: State) => IterableIterator -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>strategy("Nothing", function*(state: State) { yield state;}) : (a: State) => IterableIterator +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ >"Nothing" : "Nothing" > : ^^^^^^^^^ ->function*(state: State) { yield state;} : (state: State) => Generator -> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function*(state: State) { yield state;} : (state: State) => Generator +> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >state : State > : ^^^^^ yield state; ->yield state : undefined -> : ^^^^^^^^^ +>yield state : any +> : ^^^ >state : State > : ^^^^^ @@ -117,22 +117,22 @@ export const Nothing2: Strategy = strategy("Nothing", function*(state: St export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { >Nothing3 : Strategy > : ^^^^^^^^^^^^^^^ ->strategy("Nothing", function* (state: State) { yield ; return state;}) : (a: any) => IterableIterator -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>strategy("Nothing", function* (state: State) { yield ; return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: State) => IterableIterator +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ >"Nothing" : "Nothing" > : ^^^^^^^^^ ->function* (state: State) { yield ; return state;} : (state: State) => Generator -> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* (state: State) { yield ; return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.} : (state: State) => Generator +> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >state : State > : ^^^^^ yield ; ->yield : undefined -> : ^^^^^^^^^ +>yield : any +> : ^^^ - return state; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. >state : State > : ^^^^^ diff --git a/tests/baselines/reference/generatorTypeCheck63.errors.txt b/tests/baselines/reference/generatorTypeCheck63.errors.txt index e2045c7207c45..b13d18ebeed21 100644 --- a/tests/baselines/reference/generatorTypeCheck63.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck63.errors.txt @@ -1,18 +1,32 @@ -generatorTypeCheck63.ts(24,61): error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: State) => IterableIterator'. - Call signature return types 'Generator' and 'IterableIterator' are incompatible. +generatorTypeCheck63.ts(24,61): error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: State) => IterableIterator'. + Call signature return types 'Generator' and 'IterableIterator' are incompatible. The types returned by 'next(...)' are incompatible between these types. - Type 'IteratorResult' is not assignable to type 'IteratorResult'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. + Type 'IteratorResult' is not assignable to type 'IteratorResult'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult'. Type 'number' is not assignable to type 'State'. +generatorTypeCheck63.ts(32,62): error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: State) => IterableIterator'. + Call signature return types 'Generator' and 'IterableIterator' are incompatible. + The types returned by 'next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult'. + Type 'IteratorReturnResult' is not assignable to type 'IteratorResult'. + Type 'IteratorReturnResult' is not assignable to type 'IteratorReturnResult'. + Type 'number' is not assignable to type 'void'. +generatorTypeCheck63.ts(36,62): error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: State) => IterableIterator'. + Call signature return types 'Generator' and 'IterableIterator' are incompatible. + The types returned by 'next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult'. + Type 'IteratorReturnResult' is not assignable to type 'IteratorResult'. + Type 'IteratorReturnResult' is not assignable to type 'IteratorReturnResult'. + Type 'number' is not assignable to type 'void'. -==== generatorTypeCheck63.ts (1 errors) ==== +==== generatorTypeCheck63.ts (3 errors) ==== export interface StrategicState { lastStrategyApplied?: string; } - export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { + export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { return function*(state) { for (const next of gen(state)) { if (next) { @@ -24,7 +38,7 @@ generatorTypeCheck63.ts(24,61): error TS2345: Argument of type '(state: State) = } export interface Strategy { - (a: T): IterableIterator; + (a: T): IterableIterator; } export interface State extends StrategicState { @@ -33,25 +47,41 @@ generatorTypeCheck63.ts(24,61): error TS2345: Argument of type '(state: State) = export const Nothing: Strategy = strategy("Nothing", function* (state: State) { ~~~~~~~~ -!!! error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: State) => IterableIterator'. -!!! error TS2345: Call signature return types 'Generator' and 'IterableIterator' are incompatible. +!!! error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: State) => IterableIterator'. +!!! error TS2345: Call signature return types 'Generator' and 'IterableIterator' are incompatible. !!! error TS2345: The types returned by 'next(...)' are incompatible between these types. -!!! error TS2345: Type 'IteratorResult' is not assignable to type 'IteratorResult'. -!!! error TS2345: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. +!!! error TS2345: Type 'IteratorResult' is not assignable to type 'IteratorResult'. +!!! error TS2345: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. !!! error TS2345: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult'. !!! error TS2345: Type 'number' is not assignable to type 'State'. - yield 1; - return state; + yield 1; // number isn't a `State`, so this should error. + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); export const Nothing1: Strategy = strategy("Nothing", function* (state: State) { }); export const Nothing2: Strategy = strategy("Nothing", function* (state: State) { - return 1; + ~~~~~~~~ +!!! error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: State) => IterableIterator'. +!!! error TS2345: Call signature return types 'Generator' and 'IterableIterator' are incompatible. +!!! error TS2345: The types returned by 'next(...)' are incompatible between these types. +!!! error TS2345: Type 'IteratorResult' is not assignable to type 'IteratorResult'. +!!! error TS2345: Type 'IteratorReturnResult' is not assignable to type 'IteratorResult'. +!!! error TS2345: Type 'IteratorReturnResult' is not assignable to type 'IteratorReturnResult'. +!!! error TS2345: Type 'number' is not assignable to type 'void'. + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { + ~~~~~~~~ +!!! error TS2345: Argument of type '(state: State) => Generator' is not assignable to parameter of type '(a: State) => IterableIterator'. +!!! error TS2345: Call signature return types 'Generator' and 'IterableIterator' are incompatible. +!!! error TS2345: The types returned by 'next(...)' are incompatible between these types. +!!! error TS2345: Type 'IteratorResult' is not assignable to type 'IteratorResult'. +!!! error TS2345: Type 'IteratorReturnResult' is not assignable to type 'IteratorResult'. +!!! error TS2345: Type 'IteratorReturnResult' is not assignable to type 'IteratorReturnResult'. +!!! error TS2345: Type 'number' is not assignable to type 'void'. yield state; - return 1; + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); \ No newline at end of file diff --git a/tests/baselines/reference/generatorTypeCheck63.js b/tests/baselines/reference/generatorTypeCheck63.js index f1f4d3ee52e81..0aaf78ccacfac 100644 --- a/tests/baselines/reference/generatorTypeCheck63.js +++ b/tests/baselines/reference/generatorTypeCheck63.js @@ -5,7 +5,7 @@ export interface StrategicState { lastStrategyApplied?: string; } -export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { +export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { return function*(state) { for (const next of gen(state)) { if (next) { @@ -17,7 +17,7 @@ export function strategy(stratName: string, gen: (a: T } export interface Strategy { - (a: T): IterableIterator; + (a: T): IterableIterator; } export interface State extends StrategicState { @@ -25,20 +25,20 @@ export interface State extends StrategicState { } export const Nothing: Strategy = strategy("Nothing", function* (state: State) { - yield 1; - return state; + yield 1; // number isn't a `State`, so this should error. + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); export const Nothing1: Strategy = strategy("Nothing", function* (state: State) { }); export const Nothing2: Strategy = strategy("Nothing", function* (state: State) { - return 1; + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { yield state; - return 1; + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); //// [generatorTypeCheck63.js] @@ -57,15 +57,15 @@ function strategy(stratName, gen) { }; } exports.Nothing = strategy("Nothing", function* (state) { - yield 1; - return state; + yield 1; // number isn't a `State`, so this should error. + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); exports.Nothing1 = strategy("Nothing", function* (state) { }); exports.Nothing2 = strategy("Nothing", function* (state) { - return 1; + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); exports.Nothing3 = strategy("Nothing", function* (state) { yield state; - return 1; + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); diff --git a/tests/baselines/reference/generatorTypeCheck63.symbols b/tests/baselines/reference/generatorTypeCheck63.symbols index e395f8e0a4437..d23cf0b032707 100644 --- a/tests/baselines/reference/generatorTypeCheck63.symbols +++ b/tests/baselines/reference/generatorTypeCheck63.symbols @@ -8,7 +8,7 @@ export interface StrategicState { >lastStrategyApplied : Symbol(StrategicState.lastStrategyApplied, Decl(generatorTypeCheck63.ts, 0, 33)) } -export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { +export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { >strategy : Symbol(strategy, Decl(generatorTypeCheck63.ts, 2, 1)) >T : Symbol(T, Decl(generatorTypeCheck63.ts, 4, 25)) >StrategicState : Symbol(StrategicState, Decl(generatorTypeCheck63.ts, 0, 0)) @@ -18,7 +18,7 @@ export function strategy(stratName: string, gen: (a: T >T : Symbol(T, Decl(generatorTypeCheck63.ts, 4, 25)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) >T : Symbol(T, Decl(generatorTypeCheck63.ts, 4, 25)) ->a : Symbol(a, Decl(generatorTypeCheck63.ts, 4, 120)) +>a : Symbol(a, Decl(generatorTypeCheck63.ts, 4, 126)) >T : Symbol(T, Decl(generatorTypeCheck63.ts, 4, 25)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) >T : Symbol(T, Decl(generatorTypeCheck63.ts, 4, 25)) @@ -50,7 +50,7 @@ export interface Strategy { >Strategy : Symbol(Strategy, Decl(generatorTypeCheck63.ts, 13, 1)) >T : Symbol(T, Decl(generatorTypeCheck63.ts, 15, 26)) - (a: T): IterableIterator; + (a: T): IterableIterator; >a : Symbol(a, Decl(generatorTypeCheck63.ts, 16, 5)) >T : Symbol(T, Decl(generatorTypeCheck63.ts, 15, 26)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) @@ -73,8 +73,8 @@ export const Nothing: Strategy = strategy("Nothing", function* (state: St >state : Symbol(state, Decl(generatorTypeCheck63.ts, 23, 71)) >State : Symbol(State, Decl(generatorTypeCheck63.ts, 17, 1)) - yield 1; - return state; + yield 1; // number isn't a `State`, so this should error. + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. >state : Symbol(state, Decl(generatorTypeCheck63.ts, 23, 71)) }); @@ -97,7 +97,7 @@ export const Nothing2: Strategy = strategy("Nothing", function* (state: S >state : Symbol(state, Decl(generatorTypeCheck63.ts, 31, 72)) >State : Symbol(State, Decl(generatorTypeCheck63.ts, 17, 1)) - return 1; + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { @@ -111,5 +111,5 @@ export const Nothing3: Strategy = strategy("Nothing", function* (state: S yield state; >state : Symbol(state, Decl(generatorTypeCheck63.ts, 35, 72)) - return 1; + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); diff --git a/tests/baselines/reference/generatorTypeCheck63.types b/tests/baselines/reference/generatorTypeCheck63.types index 9efb4d642b8d7..0a3419f300b27 100644 --- a/tests/baselines/reference/generatorTypeCheck63.types +++ b/tests/baselines/reference/generatorTypeCheck63.types @@ -7,31 +7,31 @@ export interface StrategicState { > : ^^^^^^ } -export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { ->strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { +>strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ >stratName : string > : ^^^^^^ ->gen : (a: T) => IterableIterator -> : ^ ^^ ^^^^^ +>gen : (a: T) => IterableIterator +> : ^ ^^ ^^^^^ >a : T > : ^ >a : T > : ^ return function*(state) { ->function*(state) { for (const next of gen(state)) { if (next) { next.lastStrategyApplied = stratName; } yield next; } } : (state: T) => Generator -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function*(state) { for (const next of gen(state)) { if (next) { next.lastStrategyApplied = stratName; } yield next; } } : (state: T) => Generator +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >state : T > : ^ for (const next of gen(state)) { >next : T > : ^ ->gen(state) : IterableIterator -> : ^^^^^^^^^^^^^^^^^^^ ->gen : (a: T) => IterableIterator -> : ^ ^^ ^^^^^ +>gen(state) : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>gen : (a: T) => IterableIterator +> : ^ ^^ ^^^^^ >state : T > : ^ @@ -52,8 +52,8 @@ export function strategy(stratName: string, gen: (a: T > : ^^^^^^ } yield next; ->yield next : undefined -> : ^^^^^^^^^ +>yield next : any +> : ^^^ >next : T > : ^ } @@ -61,7 +61,7 @@ export function strategy(stratName: string, gen: (a: T } export interface Strategy { - (a: T): IterableIterator; + (a: T): IterableIterator; >a : T > : ^ } @@ -75,24 +75,24 @@ export interface State extends StrategicState { export const Nothing: Strategy = strategy("Nothing", function* (state: State) { >Nothing : Strategy > : ^^^^^^^^^^^^^^^ ->strategy("Nothing", function* (state: State) { yield 1; return state;}) : (a: State) => IterableIterator -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>strategy("Nothing", function* (state: State) { yield 1; // number isn't a `State`, so this should error. return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: State) => IterableIterator +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ >"Nothing" : "Nothing" > : ^^^^^^^^^ ->function* (state: State) { yield 1; return state;} : (state: State) => Generator -> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* (state: State) { yield 1; // number isn't a `State`, so this should error. return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.} : (state: State) => Generator +> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >state : State > : ^^^^^ - yield 1; ->yield 1 : undefined -> : ^^^^^^^^^ + yield 1; // number isn't a `State`, so this should error. +>yield 1 : any +> : ^^^ >1 : 1 > : ^ - return state; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. >state : State > : ^^^^^ @@ -101,14 +101,14 @@ export const Nothing: Strategy = strategy("Nothing", function* (state: St export const Nothing1: Strategy = strategy("Nothing", function* (state: State) { >Nothing1 : Strategy > : ^^^^^^^^^^^^^^^ ->strategy("Nothing", function* (state: State) {}) : (a: State) => IterableIterator -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>strategy("Nothing", function* (state: State) {}) : (a: State) => IterableIterator +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ >"Nothing" : "Nothing" > : ^^^^^^^^^ ->function* (state: State) {} : (state: State) => Generator -> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* (state: State) {} : (state: State) => Generator +> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >state : State > : ^^^^^ @@ -117,18 +117,18 @@ export const Nothing1: Strategy = strategy("Nothing", function* (state: S export const Nothing2: Strategy = strategy("Nothing", function* (state: State) { >Nothing2 : Strategy > : ^^^^^^^^^^^^^^^ ->strategy("Nothing", function* (state: State) { return 1;}) : (a: State) => IterableIterator -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>strategy("Nothing", function* (state: State) { return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: State) => IterableIterator +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ >"Nothing" : "Nothing" > : ^^^^^^^^^ ->function* (state: State) { return 1;} : (state: State) => Generator -> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* (state: State) { return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error.} : (state: State) => Generator +> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >state : State > : ^^^^^ - return 1; + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. >1 : 1 > : ^ @@ -137,24 +137,24 @@ export const Nothing2: Strategy = strategy("Nothing", function* (state: S export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { >Nothing3 : Strategy > : ^^^^^^^^^^^^^^^ ->strategy("Nothing", function* (state: State) { yield state; return 1;}) : (a: State) => IterableIterator -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>strategy("Nothing", function* (state: State) { yield state; return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: State) => IterableIterator +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ >"Nothing" : "Nothing" > : ^^^^^^^^^ ->function* (state: State) { yield state; return 1;} : (state: State) => Generator -> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* (state: State) { yield state; return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error.} : (state: State) => Generator +> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >state : State > : ^^^^^ yield state; ->yield state : undefined -> : ^^^^^^^^^ +>yield state : any +> : ^^^ >state : State > : ^^^^^ - return 1; + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. >1 : 1 > : ^ diff --git a/tests/baselines/reference/generatorTypeCheck7.errors.txt b/tests/baselines/reference/generatorTypeCheck7.errors.txt index db8a668fd9f07..fc3e9880926c0 100644 --- a/tests/baselines/reference/generatorTypeCheck7.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck7.errors.txt @@ -1,4 +1,4 @@ -generatorTypeCheck7.ts(4,17): error TS2741: Property 'hello' is missing in type 'Generator' but required in type 'WeirdIter'. +generatorTypeCheck7.ts(4,17): error TS2741: Property 'hello' is missing in type 'Generator' but required in type 'WeirdIter'. ==== generatorTypeCheck7.ts (1 errors) ==== @@ -7,5 +7,5 @@ generatorTypeCheck7.ts(4,17): error TS2741: Property 'hello' is missing in type } function* g1(): WeirdIter { } ~~~~~~~~~ -!!! error TS2741: Property 'hello' is missing in type 'Generator' but required in type 'WeirdIter'. +!!! error TS2741: Property 'hello' is missing in type 'Generator' but required in type 'WeirdIter'. !!! related TS2728 generatorTypeCheck7.ts:2:5: 'hello' is declared here. \ No newline at end of file diff --git a/tests/baselines/reference/generatorTypeCheck8.errors.txt b/tests/baselines/reference/generatorTypeCheck8.errors.txt index b7cd014a3eeaa..532e0a4c4541d 100644 --- a/tests/baselines/reference/generatorTypeCheck8.errors.txt +++ b/tests/baselines/reference/generatorTypeCheck8.errors.txt @@ -1,4 +1,4 @@ -generatorTypeCheck8.ts(2,17): error TS2322: Type 'Generator' is not assignable to type 'BadGenerator'. +generatorTypeCheck8.ts(2,17): error TS2322: Type 'Generator' is not assignable to type 'BadGenerator'. The types returned by 'next(...)' are incompatible between these types. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. @@ -10,7 +10,7 @@ generatorTypeCheck8.ts(2,17): error TS2322: Type 'Generator, Iterable { } function* g3(): BadGenerator { } ~~~~~~~~~~~~ -!!! error TS2322: Type 'Generator' is not assignable to type 'BadGenerator'. +!!! error TS2322: Type 'Generator' is not assignable to type 'BadGenerator'. !!! error TS2322: The types returned by 'next(...)' are incompatible between these types. !!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. !!! error TS2322: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. diff --git a/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types b/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types index de022f3da9373..3bf6420170b9d 100644 --- a/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types +++ b/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types @@ -2,8 +2,8 @@ === main.ts === export async function * f() { ->f : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ await 1; >await 1 : 1 diff --git a/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=false,strictbuiltiniteratorreturn=false).js b/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=false,strictbuiltiniteratorreturn=false).js new file mode 100644 index 0000000000000..a3915d2aa8930 --- /dev/null +++ b/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=false,strictbuiltiniteratorreturn=false).js @@ -0,0 +1,111 @@ +//// [tests/cases/compiler/isolatedDeclarationsStrictBuiltinIteratorReturn.ts] //// + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.ts] +declare let x1: Iterable; +declare let x2: Iterable; +declare let x3: Iterable; +declare let x4: Iterable; +declare let x5: Iterable; +declare let x6: Iterable; +declare let x7: Iterable; + +declare let x8: IterableIterator; +declare let x9: IterableIterator; +declare let x10: IterableIterator; +declare let x11: IterableIterator; +declare let x12: IterableIterator; +declare let x13: IterableIterator; +declare let x14: IterableIterator; + +declare function f1(): Iterable; +declare function f2(): Iterable; +declare function f3(): Iterable; +declare function f4(): Iterable; +declare function f5(): Iterable; +declare function f6(): Iterable; +declare function f7(): Iterable; + +declare function f8(): IterableIterator; +declare function f9(): IterableIterator; +declare function f10(): IterableIterator; +declare function f11(): IterableIterator; +declare function f12(): IterableIterator; +declare function f13(): IterableIterator; +declare function f14(): IterableIterator; + +const a1 = (): Iterable => null!; +const a2 = (): Iterable => null!; +const a3 = (): Iterable => null!; +const a4 = (): Iterable => null!; +const a5 = (): Iterable => null!; +const a6 = (): Iterable => null!; +const a7 = (): Iterable => null!; + +const a8 = (): IterableIterator => null!; +const a9 = (): IterableIterator => null!; +const a10 = (): IterableIterator => null!; +const a11 = (): IterableIterator => null!; +const a12 = (): IterableIterator => null!; +const a13 = (): IterableIterator => null!; +const a14 = (): IterableIterator => null!; + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.js] +const a1 = () => null; +const a2 = () => null; +const a3 = () => null; +const a4 = () => null; +const a5 = () => null; +const a6 = () => null; +const a7 = () => null; +const a8 = () => null; +const a9 = () => null; +const a10 = () => null; +const a11 = () => null; +const a12 = () => null; +const a13 = () => null; +const a14 = () => null; + + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.d.ts] +declare let x1: Iterable; +declare let x2: Iterable; +declare let x3: Iterable; +declare let x4: Iterable; +declare let x5: Iterable; +declare let x6: Iterable; +declare let x7: Iterable; +declare let x8: IterableIterator; +declare let x9: IterableIterator; +declare let x10: IterableIterator; +declare let x11: IterableIterator; +declare let x12: IterableIterator; +declare let x13: IterableIterator; +declare let x14: IterableIterator; +declare function f1(): Iterable; +declare function f2(): Iterable; +declare function f3(): Iterable; +declare function f4(): Iterable; +declare function f5(): Iterable; +declare function f6(): Iterable; +declare function f7(): Iterable; +declare function f8(): IterableIterator; +declare function f9(): IterableIterator; +declare function f10(): IterableIterator; +declare function f11(): IterableIterator; +declare function f12(): IterableIterator; +declare function f13(): IterableIterator; +declare function f14(): IterableIterator; +declare const a1: () => Iterable; +declare const a2: () => Iterable; +declare const a3: () => Iterable; +declare const a4: () => Iterable; +declare const a5: () => Iterable; +declare const a6: () => Iterable; +declare const a7: () => Iterable; +declare const a8: () => IterableIterator; +declare const a9: () => IterableIterator; +declare const a10: () => IterableIterator; +declare const a11: () => IterableIterator; +declare const a12: () => IterableIterator; +declare const a13: () => IterableIterator; +declare const a14: () => IterableIterator; diff --git a/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=false,strictbuiltiniteratorreturn=true).js b/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=false,strictbuiltiniteratorreturn=true).js new file mode 100644 index 0000000000000..a3915d2aa8930 --- /dev/null +++ b/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=false,strictbuiltiniteratorreturn=true).js @@ -0,0 +1,111 @@ +//// [tests/cases/compiler/isolatedDeclarationsStrictBuiltinIteratorReturn.ts] //// + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.ts] +declare let x1: Iterable; +declare let x2: Iterable; +declare let x3: Iterable; +declare let x4: Iterable; +declare let x5: Iterable; +declare let x6: Iterable; +declare let x7: Iterable; + +declare let x8: IterableIterator; +declare let x9: IterableIterator; +declare let x10: IterableIterator; +declare let x11: IterableIterator; +declare let x12: IterableIterator; +declare let x13: IterableIterator; +declare let x14: IterableIterator; + +declare function f1(): Iterable; +declare function f2(): Iterable; +declare function f3(): Iterable; +declare function f4(): Iterable; +declare function f5(): Iterable; +declare function f6(): Iterable; +declare function f7(): Iterable; + +declare function f8(): IterableIterator; +declare function f9(): IterableIterator; +declare function f10(): IterableIterator; +declare function f11(): IterableIterator; +declare function f12(): IterableIterator; +declare function f13(): IterableIterator; +declare function f14(): IterableIterator; + +const a1 = (): Iterable => null!; +const a2 = (): Iterable => null!; +const a3 = (): Iterable => null!; +const a4 = (): Iterable => null!; +const a5 = (): Iterable => null!; +const a6 = (): Iterable => null!; +const a7 = (): Iterable => null!; + +const a8 = (): IterableIterator => null!; +const a9 = (): IterableIterator => null!; +const a10 = (): IterableIterator => null!; +const a11 = (): IterableIterator => null!; +const a12 = (): IterableIterator => null!; +const a13 = (): IterableIterator => null!; +const a14 = (): IterableIterator => null!; + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.js] +const a1 = () => null; +const a2 = () => null; +const a3 = () => null; +const a4 = () => null; +const a5 = () => null; +const a6 = () => null; +const a7 = () => null; +const a8 = () => null; +const a9 = () => null; +const a10 = () => null; +const a11 = () => null; +const a12 = () => null; +const a13 = () => null; +const a14 = () => null; + + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.d.ts] +declare let x1: Iterable; +declare let x2: Iterable; +declare let x3: Iterable; +declare let x4: Iterable; +declare let x5: Iterable; +declare let x6: Iterable; +declare let x7: Iterable; +declare let x8: IterableIterator; +declare let x9: IterableIterator; +declare let x10: IterableIterator; +declare let x11: IterableIterator; +declare let x12: IterableIterator; +declare let x13: IterableIterator; +declare let x14: IterableIterator; +declare function f1(): Iterable; +declare function f2(): Iterable; +declare function f3(): Iterable; +declare function f4(): Iterable; +declare function f5(): Iterable; +declare function f6(): Iterable; +declare function f7(): Iterable; +declare function f8(): IterableIterator; +declare function f9(): IterableIterator; +declare function f10(): IterableIterator; +declare function f11(): IterableIterator; +declare function f12(): IterableIterator; +declare function f13(): IterableIterator; +declare function f14(): IterableIterator; +declare const a1: () => Iterable; +declare const a2: () => Iterable; +declare const a3: () => Iterable; +declare const a4: () => Iterable; +declare const a5: () => Iterable; +declare const a6: () => Iterable; +declare const a7: () => Iterable; +declare const a8: () => IterableIterator; +declare const a9: () => IterableIterator; +declare const a10: () => IterableIterator; +declare const a11: () => IterableIterator; +declare const a12: () => IterableIterator; +declare const a13: () => IterableIterator; +declare const a14: () => IterableIterator; diff --git a/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=true,strictbuiltiniteratorreturn=false).js b/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=true,strictbuiltiniteratorreturn=false).js new file mode 100644 index 0000000000000..a3915d2aa8930 --- /dev/null +++ b/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=true,strictbuiltiniteratorreturn=false).js @@ -0,0 +1,111 @@ +//// [tests/cases/compiler/isolatedDeclarationsStrictBuiltinIteratorReturn.ts] //// + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.ts] +declare let x1: Iterable; +declare let x2: Iterable; +declare let x3: Iterable; +declare let x4: Iterable; +declare let x5: Iterable; +declare let x6: Iterable; +declare let x7: Iterable; + +declare let x8: IterableIterator; +declare let x9: IterableIterator; +declare let x10: IterableIterator; +declare let x11: IterableIterator; +declare let x12: IterableIterator; +declare let x13: IterableIterator; +declare let x14: IterableIterator; + +declare function f1(): Iterable; +declare function f2(): Iterable; +declare function f3(): Iterable; +declare function f4(): Iterable; +declare function f5(): Iterable; +declare function f6(): Iterable; +declare function f7(): Iterable; + +declare function f8(): IterableIterator; +declare function f9(): IterableIterator; +declare function f10(): IterableIterator; +declare function f11(): IterableIterator; +declare function f12(): IterableIterator; +declare function f13(): IterableIterator; +declare function f14(): IterableIterator; + +const a1 = (): Iterable => null!; +const a2 = (): Iterable => null!; +const a3 = (): Iterable => null!; +const a4 = (): Iterable => null!; +const a5 = (): Iterable => null!; +const a6 = (): Iterable => null!; +const a7 = (): Iterable => null!; + +const a8 = (): IterableIterator => null!; +const a9 = (): IterableIterator => null!; +const a10 = (): IterableIterator => null!; +const a11 = (): IterableIterator => null!; +const a12 = (): IterableIterator => null!; +const a13 = (): IterableIterator => null!; +const a14 = (): IterableIterator => null!; + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.js] +const a1 = () => null; +const a2 = () => null; +const a3 = () => null; +const a4 = () => null; +const a5 = () => null; +const a6 = () => null; +const a7 = () => null; +const a8 = () => null; +const a9 = () => null; +const a10 = () => null; +const a11 = () => null; +const a12 = () => null; +const a13 = () => null; +const a14 = () => null; + + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.d.ts] +declare let x1: Iterable; +declare let x2: Iterable; +declare let x3: Iterable; +declare let x4: Iterable; +declare let x5: Iterable; +declare let x6: Iterable; +declare let x7: Iterable; +declare let x8: IterableIterator; +declare let x9: IterableIterator; +declare let x10: IterableIterator; +declare let x11: IterableIterator; +declare let x12: IterableIterator; +declare let x13: IterableIterator; +declare let x14: IterableIterator; +declare function f1(): Iterable; +declare function f2(): Iterable; +declare function f3(): Iterable; +declare function f4(): Iterable; +declare function f5(): Iterable; +declare function f6(): Iterable; +declare function f7(): Iterable; +declare function f8(): IterableIterator; +declare function f9(): IterableIterator; +declare function f10(): IterableIterator; +declare function f11(): IterableIterator; +declare function f12(): IterableIterator; +declare function f13(): IterableIterator; +declare function f14(): IterableIterator; +declare const a1: () => Iterable; +declare const a2: () => Iterable; +declare const a3: () => Iterable; +declare const a4: () => Iterable; +declare const a5: () => Iterable; +declare const a6: () => Iterable; +declare const a7: () => Iterable; +declare const a8: () => IterableIterator; +declare const a9: () => IterableIterator; +declare const a10: () => IterableIterator; +declare const a11: () => IterableIterator; +declare const a12: () => IterableIterator; +declare const a13: () => IterableIterator; +declare const a14: () => IterableIterator; diff --git a/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=true,strictbuiltiniteratorreturn=true).js b/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=true,strictbuiltiniteratorreturn=true).js new file mode 100644 index 0000000000000..a3915d2aa8930 --- /dev/null +++ b/tests/baselines/reference/isolatedDeclarationsStrictBuiltinIteratorReturn(isolateddeclarations=true,strictbuiltiniteratorreturn=true).js @@ -0,0 +1,111 @@ +//// [tests/cases/compiler/isolatedDeclarationsStrictBuiltinIteratorReturn.ts] //// + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.ts] +declare let x1: Iterable; +declare let x2: Iterable; +declare let x3: Iterable; +declare let x4: Iterable; +declare let x5: Iterable; +declare let x6: Iterable; +declare let x7: Iterable; + +declare let x8: IterableIterator; +declare let x9: IterableIterator; +declare let x10: IterableIterator; +declare let x11: IterableIterator; +declare let x12: IterableIterator; +declare let x13: IterableIterator; +declare let x14: IterableIterator; + +declare function f1(): Iterable; +declare function f2(): Iterable; +declare function f3(): Iterable; +declare function f4(): Iterable; +declare function f5(): Iterable; +declare function f6(): Iterable; +declare function f7(): Iterable; + +declare function f8(): IterableIterator; +declare function f9(): IterableIterator; +declare function f10(): IterableIterator; +declare function f11(): IterableIterator; +declare function f12(): IterableIterator; +declare function f13(): IterableIterator; +declare function f14(): IterableIterator; + +const a1 = (): Iterable => null!; +const a2 = (): Iterable => null!; +const a3 = (): Iterable => null!; +const a4 = (): Iterable => null!; +const a5 = (): Iterable => null!; +const a6 = (): Iterable => null!; +const a7 = (): Iterable => null!; + +const a8 = (): IterableIterator => null!; +const a9 = (): IterableIterator => null!; +const a10 = (): IterableIterator => null!; +const a11 = (): IterableIterator => null!; +const a12 = (): IterableIterator => null!; +const a13 = (): IterableIterator => null!; +const a14 = (): IterableIterator => null!; + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.js] +const a1 = () => null; +const a2 = () => null; +const a3 = () => null; +const a4 = () => null; +const a5 = () => null; +const a6 = () => null; +const a7 = () => null; +const a8 = () => null; +const a9 = () => null; +const a10 = () => null; +const a11 = () => null; +const a12 = () => null; +const a13 = () => null; +const a14 = () => null; + + +//// [isolatedDeclarationsStrictBuiltinIteratorReturn.d.ts] +declare let x1: Iterable; +declare let x2: Iterable; +declare let x3: Iterable; +declare let x4: Iterable; +declare let x5: Iterable; +declare let x6: Iterable; +declare let x7: Iterable; +declare let x8: IterableIterator; +declare let x9: IterableIterator; +declare let x10: IterableIterator; +declare let x11: IterableIterator; +declare let x12: IterableIterator; +declare let x13: IterableIterator; +declare let x14: IterableIterator; +declare function f1(): Iterable; +declare function f2(): Iterable; +declare function f3(): Iterable; +declare function f4(): Iterable; +declare function f5(): Iterable; +declare function f6(): Iterable; +declare function f7(): Iterable; +declare function f8(): IterableIterator; +declare function f9(): IterableIterator; +declare function f10(): IterableIterator; +declare function f11(): IterableIterator; +declare function f12(): IterableIterator; +declare function f13(): IterableIterator; +declare function f14(): IterableIterator; +declare const a1: () => Iterable; +declare const a2: () => Iterable; +declare const a3: () => Iterable; +declare const a4: () => Iterable; +declare const a5: () => Iterable; +declare const a6: () => Iterable; +declare const a7: () => Iterable; +declare const a8: () => IterableIterator; +declare const a9: () => IterableIterator; +declare const a10: () => IterableIterator; +declare const a11: () => IterableIterator; +declare const a12: () => IterableIterator; +declare const a13: () => IterableIterator; +declare const a14: () => IterableIterator; diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).js b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).js new file mode 100644 index 0000000000000..0c0f14988e428 --- /dev/null +++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).js @@ -0,0 +1,80 @@ +//// [tests/cases/compiler/iterableTReturnTNext.ts] //// + +//// [iterableTReturnTNext.ts] +declare const map: Map; +declare const set: Set; + +// based on: +// - https://github.com/apollographql/apollo-client/blob/8740f198805a99e01136617c4055d611b92cc231/src/react/hooks/__tests__/useMutation.test.tsx#L2328 +// - https://github.com/continuedev/continue/blob/046bca088a833f8b3620412ff64e4b6f41fbb959/extensions/vscode/src/autocomplete/lsp.ts#L60 +const r1: number = map.values().next().value; // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` + +// based on: https://github.com/gcanti/fp-ts/blob/89a772e95e414acee679f42f56527606f7b61f30/src/Map.ts#L246 +interface Next { + readonly done?: boolean + readonly value: A +} +const r2: Next = map.values().next(); // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` + +// based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175 +async function* source() { yield 1; yield 2; yield 3; } +const doubles = source(); +doubles.return(); + +// based on: https://github.com/backstage/backstage/blob/85d9346ef11c1c20e4405102b4f5d93afb1292c1/packages/core-app-api/src/routing/RouteTracker.tsx#L62 +const r3: number | undefined = set.values().next().value; + +// based on: https://github.com/microsoft/TypeScript/blob/15f67e0b482faf9f6a3ab9965f3c11196bf3e99b/src/harness/compilerImpl.ts#L77 +class MyMap implements Map { + declare private _keys: string[]; + declare private _values: number[]; + declare size: number; + declare [Symbol.toStringTag]: string; + + clear(): void { } + delete(key: string): boolean { return false; } + forEach(callbackfn: (value: number, key: string, map: Map) => void, thisArg?: any): void { } + get(key: string): number | undefined { return undefined; } + has(key: string): boolean { return false; } + set(key: string, value: number): this { return this; } + entries(): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } + keys(): IterableIterator { throw new Error("Method not implemented."); } + + [Symbol.iterator](): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } + + // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined` + * values() { + yield* this._values; + } +} + + +//// [iterableTReturnTNext.js] +"use strict"; +// based on: +// - https://github.com/apollographql/apollo-client/blob/8740f198805a99e01136617c4055d611b92cc231/src/react/hooks/__tests__/useMutation.test.tsx#L2328 +// - https://github.com/continuedev/continue/blob/046bca088a833f8b3620412ff64e4b6f41fbb959/extensions/vscode/src/autocomplete/lsp.ts#L60 +const r1 = map.values().next().value; // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +const r2 = map.values().next(); // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +// based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175 +async function* source() { yield 1; yield 2; yield 3; } +const doubles = source(); +doubles.return(); +// based on: https://github.com/backstage/backstage/blob/85d9346ef11c1c20e4405102b4f5d93afb1292c1/packages/core-app-api/src/routing/RouteTracker.tsx#L62 +const r3 = set.values().next().value; +// based on: https://github.com/microsoft/TypeScript/blob/15f67e0b482faf9f6a3ab9965f3c11196bf3e99b/src/harness/compilerImpl.ts#L77 +class MyMap { + clear() { } + delete(key) { return false; } + forEach(callbackfn, thisArg) { } + get(key) { return undefined; } + has(key) { return false; } + set(key, value) { return this; } + entries() { throw new Error("Method not implemented."); } + keys() { throw new Error("Method not implemented."); } + [Symbol.iterator]() { throw new Error("Method not implemented."); } + // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined` + *values() { + yield* this._values; + } +} diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).symbols b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).symbols new file mode 100644 index 0000000000000..b72ed04227de4 --- /dev/null +++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).symbols @@ -0,0 +1,152 @@ +//// [tests/cases/compiler/iterableTReturnTNext.ts] //// + +=== iterableTReturnTNext.ts === +declare const map: Map; +>map : Symbol(map, Decl(iterableTReturnTNext.ts, 0, 13)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +declare const set: Set; +>set : Symbol(set, Decl(iterableTReturnTNext.ts, 1, 13)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.collection.d.ts, --, --)) + +// based on: +// - https://github.com/apollographql/apollo-client/blob/8740f198805a99e01136617c4055d611b92cc231/src/react/hooks/__tests__/useMutation.test.tsx#L2328 +// - https://github.com/continuedev/continue/blob/046bca088a833f8b3620412ff64e4b6f41fbb959/extensions/vscode/src/autocomplete/lsp.ts#L60 +const r1: number = map.values().next().value; // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +>r1 : Symbol(r1, Decl(iterableTReturnTNext.ts, 6, 5)) +>map.values().next().value : Symbol(value, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>map.values().next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) +>map.values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>map : Symbol(map, Decl(iterableTReturnTNext.ts, 0, 13)) +>values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) +>value : Symbol(value, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + +// based on: https://github.com/gcanti/fp-ts/blob/89a772e95e414acee679f42f56527606f7b61f30/src/Map.ts#L246 +interface Next { +>Next : Symbol(Next, Decl(iterableTReturnTNext.ts, 6, 45)) +>A : Symbol(A, Decl(iterableTReturnTNext.ts, 9, 15)) + + readonly done?: boolean +>done : Symbol(Next.done, Decl(iterableTReturnTNext.ts, 9, 19)) + + readonly value: A +>value : Symbol(Next.value, Decl(iterableTReturnTNext.ts, 10, 27)) +>A : Symbol(A, Decl(iterableTReturnTNext.ts, 9, 15)) +} +const r2: Next = map.values().next(); // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +>r2 : Symbol(r2, Decl(iterableTReturnTNext.ts, 13, 5)) +>Next : Symbol(Next, Decl(iterableTReturnTNext.ts, 6, 45)) +>map.values().next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) +>map.values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>map : Symbol(map, Decl(iterableTReturnTNext.ts, 0, 13)) +>values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) + +// based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175 +async function* source() { yield 1; yield 2; yield 3; } +>source : Symbol(source, Decl(iterableTReturnTNext.ts, 13, 45)) + +const doubles = source(); +>doubles : Symbol(doubles, Decl(iterableTReturnTNext.ts, 17, 5)) +>source : Symbol(source, Decl(iterableTReturnTNext.ts, 13, 45)) + +doubles.return(); +>doubles.return : Symbol(AsyncGenerator.return, Decl(lib.es2018.asyncgenerator.d.ts, --, --)) +>doubles : Symbol(doubles, Decl(iterableTReturnTNext.ts, 17, 5)) +>return : Symbol(AsyncGenerator.return, Decl(lib.es2018.asyncgenerator.d.ts, --, --)) + +// based on: https://github.com/backstage/backstage/blob/85d9346ef11c1c20e4405102b4f5d93afb1292c1/packages/core-app-api/src/routing/RouteTracker.tsx#L62 +const r3: number | undefined = set.values().next().value; +>r3 : Symbol(r3, Decl(iterableTReturnTNext.ts, 21, 5)) +>set.values().next().value : Symbol(value, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>set.values().next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) +>set.values : Symbol(Set.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>set : Symbol(set, Decl(iterableTReturnTNext.ts, 1, 13)) +>values : Symbol(Set.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) +>value : Symbol(value, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + +// based on: https://github.com/microsoft/TypeScript/blob/15f67e0b482faf9f6a3ab9965f3c11196bf3e99b/src/harness/compilerImpl.ts#L77 +class MyMap implements Map { +>MyMap : Symbol(MyMap, Decl(iterableTReturnTNext.ts, 21, 57)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + + declare private _keys: string[]; +>_keys : Symbol(MyMap._keys, Decl(iterableTReturnTNext.ts, 24, 44)) + + declare private _values: number[]; +>_values : Symbol(MyMap._values, Decl(iterableTReturnTNext.ts, 25, 36)) + + declare size: number; +>size : Symbol(MyMap.size, Decl(iterableTReturnTNext.ts, 26, 38)) + + declare [Symbol.toStringTag]: string; +>[Symbol.toStringTag] : Symbol(MyMap[Symbol.toStringTag], Decl(iterableTReturnTNext.ts, 27, 25)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + + clear(): void { } +>clear : Symbol(MyMap.clear, Decl(iterableTReturnTNext.ts, 28, 41)) + + delete(key: string): boolean { return false; } +>delete : Symbol(MyMap.delete, Decl(iterableTReturnTNext.ts, 30, 21)) +>key : Symbol(key, Decl(iterableTReturnTNext.ts, 31, 11)) + + forEach(callbackfn: (value: number, key: string, map: Map) => void, thisArg?: any): void { } +>forEach : Symbol(MyMap.forEach, Decl(iterableTReturnTNext.ts, 31, 50)) +>callbackfn : Symbol(callbackfn, Decl(iterableTReturnTNext.ts, 32, 12)) +>value : Symbol(value, Decl(iterableTReturnTNext.ts, 32, 25)) +>key : Symbol(key, Decl(iterableTReturnTNext.ts, 32, 39)) +>map : Symbol(map, Decl(iterableTReturnTNext.ts, 32, 52)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>thisArg : Symbol(thisArg, Decl(iterableTReturnTNext.ts, 32, 87)) + + get(key: string): number | undefined { return undefined; } +>get : Symbol(MyMap.get, Decl(iterableTReturnTNext.ts, 32, 112)) +>key : Symbol(key, Decl(iterableTReturnTNext.ts, 33, 8)) +>undefined : Symbol(undefined) + + has(key: string): boolean { return false; } +>has : Symbol(MyMap.has, Decl(iterableTReturnTNext.ts, 33, 62)) +>key : Symbol(key, Decl(iterableTReturnTNext.ts, 34, 8)) + + set(key: string, value: number): this { return this; } +>set : Symbol(MyMap.set, Decl(iterableTReturnTNext.ts, 34, 47)) +>key : Symbol(key, Decl(iterableTReturnTNext.ts, 35, 8)) +>value : Symbol(value, Decl(iterableTReturnTNext.ts, 35, 20)) +>this : Symbol(MyMap, Decl(iterableTReturnTNext.ts, 21, 57)) + + entries(): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } +>entries : Symbol(MyMap.entries, Decl(iterableTReturnTNext.ts, 35, 58)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) + + keys(): IterableIterator { throw new Error("Method not implemented."); } +>keys : Symbol(MyMap.keys, Decl(iterableTReturnTNext.ts, 36, 120)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) + + [Symbol.iterator](): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } +>[Symbol.iterator] : Symbol(MyMap[Symbol.iterator], Decl(iterableTReturnTNext.ts, 37, 107)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) + + // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined` + * values() { +>values : Symbol(MyMap.values, Decl(iterableTReturnTNext.ts, 39, 130)) + + yield* this._values; +>this._values : Symbol(MyMap._values, Decl(iterableTReturnTNext.ts, 25, 36)) +>this : Symbol(MyMap, Decl(iterableTReturnTNext.ts, 21, 57)) +>_values : Symbol(MyMap._values, Decl(iterableTReturnTNext.ts, 25, 36)) + } +} + diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).types b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).types new file mode 100644 index 0000000000000..11831b7d4eb31 --- /dev/null +++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).types @@ -0,0 +1,247 @@ +//// [tests/cases/compiler/iterableTReturnTNext.ts] //// + +=== iterableTReturnTNext.ts === +declare const map: Map; +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ + +declare const set: Set; +>set : Set +> : ^^^^^^^^^^^ + +// based on: +// - https://github.com/apollographql/apollo-client/blob/8740f198805a99e01136617c4055d611b92cc231/src/react/hooks/__tests__/useMutation.test.tsx#L2328 +// - https://github.com/continuedev/continue/blob/046bca088a833f8b3620412ff64e4b6f41fbb959/extensions/vscode/src/autocomplete/lsp.ts#L60 +const r1: number = map.values().next().value; // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +>r1 : number +> : ^^^^^^ +>map.values().next().value : any +>map.values().next() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values().next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>value : any +> : ^^^ + +// based on: https://github.com/gcanti/fp-ts/blob/89a772e95e414acee679f42f56527606f7b61f30/src/Map.ts#L246 +interface Next { + readonly done?: boolean +>done : boolean | undefined +> : ^^^^^^^^^^^^^^^^^^^ + + readonly value: A +>value : A +> : ^ +} +const r2: Next = map.values().next(); // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +>r2 : Next +> : ^^^^^^^^^^^^ +>map.values().next() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values().next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +// based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175 +async function* source() { yield 1; yield 2; yield 3; } +>source : () => AsyncGenerator<1 | 2 | 3, void, unknown> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield 1 : any +>1 : 1 +> : ^ +>yield 2 : any +>2 : 2 +> : ^ +>yield 3 : any +>3 : 3 +> : ^ + +const doubles = source(); +>doubles : AsyncGenerator<1 | 2 | 3, void, unknown> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>source() : AsyncGenerator<1 | 2 | 3, void, unknown> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>source : () => AsyncGenerator<1 | 2 | 3, void, unknown> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +doubles.return(); +>doubles.return() : Promise> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>doubles.return : (value: void | PromiseLike) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>doubles : AsyncGenerator<1 | 2 | 3, void, unknown> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>return : (value: void | PromiseLike) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +// based on: https://github.com/backstage/backstage/blob/85d9346ef11c1c20e4405102b4f5d93afb1292c1/packages/core-app-api/src/routing/RouteTracker.tsx#L62 +const r3: number | undefined = set.values().next().value; +>r3 : number | undefined +> : ^^^^^^^^^^^^^^^^^^ +>set.values().next().value : any +>set.values().next() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.values().next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>set.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set : Set +> : ^^^^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>value : any +> : ^^^ + +// based on: https://github.com/microsoft/TypeScript/blob/15f67e0b482faf9f6a3ab9965f3c11196bf3e99b/src/harness/compilerImpl.ts#L77 +class MyMap implements Map { +>MyMap : MyMap +> : ^^^^^ + + declare private _keys: string[]; +>_keys : string[] +> : ^^^^^^^^ + + declare private _values: number[]; +>_values : number[] +> : ^^^^^^^^ + + declare size: number; +>size : number +> : ^^^^^^ + + declare [Symbol.toStringTag]: string; +>[Symbol.toStringTag] : string +> : ^^^^^^ +>Symbol.toStringTag : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>toStringTag : unique symbol +> : ^^^^^^^^^^^^^ + + clear(): void { } +>clear : () => void +> : ^^^^^^ + + delete(key: string): boolean { return false; } +>delete : (key: string) => boolean +> : ^ ^^ ^^^^^ +>key : string +> : ^^^^^^ +>false : false +> : ^^^^^ + + forEach(callbackfn: (value: number, key: string, map: Map) => void, thisArg?: any): void { } +>forEach : (callbackfn: (value: number, key: string, map: Map) => void, thisArg?: any) => void +> : ^ ^^ ^^ ^^^ ^^^^^ +>callbackfn : (value: number, key: string, map: Map) => void +> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^ +>value : number +> : ^^^^^^ +>key : string +> : ^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>thisArg : any + + get(key: string): number | undefined { return undefined; } +>get : (key: string) => number | undefined +> : ^ ^^ ^^^^^ +>key : string +> : ^^^^^^ +>undefined : undefined +> : ^^^^^^^^^ + + has(key: string): boolean { return false; } +>has : (key: string) => boolean +> : ^ ^^ ^^^^^ +>key : string +> : ^^^^^^ +>false : false +> : ^^^^^ + + set(key: string, value: number): this { return this; } +>set : (key: string, value: number) => this +> : ^ ^^ ^^ ^^ ^^^^^ +>key : string +> : ^^^^^^ +>value : number +> : ^^^^^^ +>this : this +> : ^^^^ + + entries(): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } +>entries : () => IterableIterator<[string, number], BuiltinIteratorReturn> +> : ^^^^^^ +>new Error("Method not implemented.") : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +>"Method not implemented." : "Method not implemented." +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + keys(): IterableIterator { throw new Error("Method not implemented."); } +>keys : () => IterableIterator +> : ^^^^^^ +>new Error("Method not implemented.") : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +>"Method not implemented." : "Method not implemented." +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + [Symbol.iterator](): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } +>[Symbol.iterator] : () => IterableIterator<[string, number], BuiltinIteratorReturn> +> : ^^^^^^ +>Symbol.iterator : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>iterator : unique symbol +> : ^^^^^^^^^^^^^ +>new Error("Method not implemented.") : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +>"Method not implemented." : "Method not implemented." +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined` + * values() { +>values : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + yield* this._values; +>yield* this._values : any +>this._values : number[] +> : ^^^^^^^^ +>this : this +> : ^^^^ +>_values : number[] +> : ^^^^^^^^ + } +} + diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).errors.txt b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).errors.txt new file mode 100644 index 0000000000000..f5134dd19f0f3 --- /dev/null +++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).errors.txt @@ -0,0 +1,81 @@ +iterableTReturnTNext.ts(7,7): error TS2322: Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iterableTReturnTNext.ts(14,7): error TS2322: Type 'IteratorResult' is not assignable to type 'Next'. + Type 'IteratorReturnResult' is not assignable to type 'Next'. + Types of property 'value' are incompatible. + Type 'undefined' is not assignable to type 'number'. +iterableTReturnTNext.ts(43,7): error TS2416: Property 'values' in type 'MyMap' is not assignable to the same property in base type 'Map'. + Type '() => Generator' is not assignable to type '() => IterableIterator'. + Call signature return types 'Generator' and 'IterableIterator' are incompatible. + The types returned by 'next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult'. + Type 'IteratorReturnResult' is not assignable to type 'IteratorResult'. + Type 'IteratorReturnResult' is not assignable to type 'IteratorReturnResult'. + Type 'void' is not assignable to type 'undefined'. + + +==== iterableTReturnTNext.ts (3 errors) ==== + declare const map: Map; + declare const set: Set; + + // based on: + // - https://github.com/apollographql/apollo-client/blob/8740f198805a99e01136617c4055d611b92cc231/src/react/hooks/__tests__/useMutation.test.tsx#L2328 + // - https://github.com/continuedev/continue/blob/046bca088a833f8b3620412ff64e4b6f41fbb959/extensions/vscode/src/autocomplete/lsp.ts#L60 + const r1: number = map.values().next().value; // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` + ~~ +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + // based on: https://github.com/gcanti/fp-ts/blob/89a772e95e414acee679f42f56527606f7b61f30/src/Map.ts#L246 + interface Next { + readonly done?: boolean + readonly value: A + } + const r2: Next = map.values().next(); // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` + ~~ +!!! error TS2322: Type 'IteratorResult' is not assignable to type 'Next'. +!!! error TS2322: Type 'IteratorReturnResult' is not assignable to type 'Next'. +!!! error TS2322: Types of property 'value' are incompatible. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + // based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175 + async function* source() { yield 1; yield 2; yield 3; } + const doubles = source(); + doubles.return(); + + // based on: https://github.com/backstage/backstage/blob/85d9346ef11c1c20e4405102b4f5d93afb1292c1/packages/core-app-api/src/routing/RouteTracker.tsx#L62 + const r3: number | undefined = set.values().next().value; + + // based on: https://github.com/microsoft/TypeScript/blob/15f67e0b482faf9f6a3ab9965f3c11196bf3e99b/src/harness/compilerImpl.ts#L77 + class MyMap implements Map { + declare private _keys: string[]; + declare private _values: number[]; + declare size: number; + declare [Symbol.toStringTag]: string; + + clear(): void { } + delete(key: string): boolean { return false; } + forEach(callbackfn: (value: number, key: string, map: Map) => void, thisArg?: any): void { } + get(key: string): number | undefined { return undefined; } + has(key: string): boolean { return false; } + set(key: string, value: number): this { return this; } + entries(): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } + keys(): IterableIterator { throw new Error("Method not implemented."); } + + [Symbol.iterator](): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } + + // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined` + * values() { + ~~~~~~ +!!! error TS2416: Property 'values' in type 'MyMap' is not assignable to the same property in base type 'Map'. +!!! error TS2416: Type '() => Generator' is not assignable to type '() => IterableIterator'. +!!! error TS2416: Call signature return types 'Generator' and 'IterableIterator' are incompatible. +!!! error TS2416: The types returned by 'next(...)' are incompatible between these types. +!!! error TS2416: Type 'IteratorResult' is not assignable to type 'IteratorResult'. +!!! error TS2416: Type 'IteratorReturnResult' is not assignable to type 'IteratorResult'. +!!! error TS2416: Type 'IteratorReturnResult' is not assignable to type 'IteratorReturnResult'. +!!! error TS2416: Type 'void' is not assignable to type 'undefined'. + yield* this._values; + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).js b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).js new file mode 100644 index 0000000000000..0c0f14988e428 --- /dev/null +++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).js @@ -0,0 +1,80 @@ +//// [tests/cases/compiler/iterableTReturnTNext.ts] //// + +//// [iterableTReturnTNext.ts] +declare const map: Map; +declare const set: Set; + +// based on: +// - https://github.com/apollographql/apollo-client/blob/8740f198805a99e01136617c4055d611b92cc231/src/react/hooks/__tests__/useMutation.test.tsx#L2328 +// - https://github.com/continuedev/continue/blob/046bca088a833f8b3620412ff64e4b6f41fbb959/extensions/vscode/src/autocomplete/lsp.ts#L60 +const r1: number = map.values().next().value; // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` + +// based on: https://github.com/gcanti/fp-ts/blob/89a772e95e414acee679f42f56527606f7b61f30/src/Map.ts#L246 +interface Next { + readonly done?: boolean + readonly value: A +} +const r2: Next = map.values().next(); // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` + +// based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175 +async function* source() { yield 1; yield 2; yield 3; } +const doubles = source(); +doubles.return(); + +// based on: https://github.com/backstage/backstage/blob/85d9346ef11c1c20e4405102b4f5d93afb1292c1/packages/core-app-api/src/routing/RouteTracker.tsx#L62 +const r3: number | undefined = set.values().next().value; + +// based on: https://github.com/microsoft/TypeScript/blob/15f67e0b482faf9f6a3ab9965f3c11196bf3e99b/src/harness/compilerImpl.ts#L77 +class MyMap implements Map { + declare private _keys: string[]; + declare private _values: number[]; + declare size: number; + declare [Symbol.toStringTag]: string; + + clear(): void { } + delete(key: string): boolean { return false; } + forEach(callbackfn: (value: number, key: string, map: Map) => void, thisArg?: any): void { } + get(key: string): number | undefined { return undefined; } + has(key: string): boolean { return false; } + set(key: string, value: number): this { return this; } + entries(): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } + keys(): IterableIterator { throw new Error("Method not implemented."); } + + [Symbol.iterator](): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } + + // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined` + * values() { + yield* this._values; + } +} + + +//// [iterableTReturnTNext.js] +"use strict"; +// based on: +// - https://github.com/apollographql/apollo-client/blob/8740f198805a99e01136617c4055d611b92cc231/src/react/hooks/__tests__/useMutation.test.tsx#L2328 +// - https://github.com/continuedev/continue/blob/046bca088a833f8b3620412ff64e4b6f41fbb959/extensions/vscode/src/autocomplete/lsp.ts#L60 +const r1 = map.values().next().value; // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +const r2 = map.values().next(); // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +// based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175 +async function* source() { yield 1; yield 2; yield 3; } +const doubles = source(); +doubles.return(); +// based on: https://github.com/backstage/backstage/blob/85d9346ef11c1c20e4405102b4f5d93afb1292c1/packages/core-app-api/src/routing/RouteTracker.tsx#L62 +const r3 = set.values().next().value; +// based on: https://github.com/microsoft/TypeScript/blob/15f67e0b482faf9f6a3ab9965f3c11196bf3e99b/src/harness/compilerImpl.ts#L77 +class MyMap { + clear() { } + delete(key) { return false; } + forEach(callbackfn, thisArg) { } + get(key) { return undefined; } + has(key) { return false; } + set(key, value) { return this; } + entries() { throw new Error("Method not implemented."); } + keys() { throw new Error("Method not implemented."); } + [Symbol.iterator]() { throw new Error("Method not implemented."); } + // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined` + *values() { + yield* this._values; + } +} diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).symbols b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).symbols new file mode 100644 index 0000000000000..b72ed04227de4 --- /dev/null +++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).symbols @@ -0,0 +1,152 @@ +//// [tests/cases/compiler/iterableTReturnTNext.ts] //// + +=== iterableTReturnTNext.ts === +declare const map: Map; +>map : Symbol(map, Decl(iterableTReturnTNext.ts, 0, 13)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +declare const set: Set; +>set : Symbol(set, Decl(iterableTReturnTNext.ts, 1, 13)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.collection.d.ts, --, --)) + +// based on: +// - https://github.com/apollographql/apollo-client/blob/8740f198805a99e01136617c4055d611b92cc231/src/react/hooks/__tests__/useMutation.test.tsx#L2328 +// - https://github.com/continuedev/continue/blob/046bca088a833f8b3620412ff64e4b6f41fbb959/extensions/vscode/src/autocomplete/lsp.ts#L60 +const r1: number = map.values().next().value; // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +>r1 : Symbol(r1, Decl(iterableTReturnTNext.ts, 6, 5)) +>map.values().next().value : Symbol(value, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>map.values().next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) +>map.values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>map : Symbol(map, Decl(iterableTReturnTNext.ts, 0, 13)) +>values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) +>value : Symbol(value, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + +// based on: https://github.com/gcanti/fp-ts/blob/89a772e95e414acee679f42f56527606f7b61f30/src/Map.ts#L246 +interface Next { +>Next : Symbol(Next, Decl(iterableTReturnTNext.ts, 6, 45)) +>A : Symbol(A, Decl(iterableTReturnTNext.ts, 9, 15)) + + readonly done?: boolean +>done : Symbol(Next.done, Decl(iterableTReturnTNext.ts, 9, 19)) + + readonly value: A +>value : Symbol(Next.value, Decl(iterableTReturnTNext.ts, 10, 27)) +>A : Symbol(A, Decl(iterableTReturnTNext.ts, 9, 15)) +} +const r2: Next = map.values().next(); // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +>r2 : Symbol(r2, Decl(iterableTReturnTNext.ts, 13, 5)) +>Next : Symbol(Next, Decl(iterableTReturnTNext.ts, 6, 45)) +>map.values().next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) +>map.values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>map : Symbol(map, Decl(iterableTReturnTNext.ts, 0, 13)) +>values : Symbol(Map.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) + +// based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175 +async function* source() { yield 1; yield 2; yield 3; } +>source : Symbol(source, Decl(iterableTReturnTNext.ts, 13, 45)) + +const doubles = source(); +>doubles : Symbol(doubles, Decl(iterableTReturnTNext.ts, 17, 5)) +>source : Symbol(source, Decl(iterableTReturnTNext.ts, 13, 45)) + +doubles.return(); +>doubles.return : Symbol(AsyncGenerator.return, Decl(lib.es2018.asyncgenerator.d.ts, --, --)) +>doubles : Symbol(doubles, Decl(iterableTReturnTNext.ts, 17, 5)) +>return : Symbol(AsyncGenerator.return, Decl(lib.es2018.asyncgenerator.d.ts, --, --)) + +// based on: https://github.com/backstage/backstage/blob/85d9346ef11c1c20e4405102b4f5d93afb1292c1/packages/core-app-api/src/routing/RouteTracker.tsx#L62 +const r3: number | undefined = set.values().next().value; +>r3 : Symbol(r3, Decl(iterableTReturnTNext.ts, 21, 5)) +>set.values().next().value : Symbol(value, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>set.values().next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) +>set.values : Symbol(Set.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>set : Symbol(set, Decl(iterableTReturnTNext.ts, 1, 13)) +>values : Symbol(Set.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --)) +>value : Symbol(value, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + +// based on: https://github.com/microsoft/TypeScript/blob/15f67e0b482faf9f6a3ab9965f3c11196bf3e99b/src/harness/compilerImpl.ts#L77 +class MyMap implements Map { +>MyMap : Symbol(MyMap, Decl(iterableTReturnTNext.ts, 21, 57)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + + declare private _keys: string[]; +>_keys : Symbol(MyMap._keys, Decl(iterableTReturnTNext.ts, 24, 44)) + + declare private _values: number[]; +>_values : Symbol(MyMap._values, Decl(iterableTReturnTNext.ts, 25, 36)) + + declare size: number; +>size : Symbol(MyMap.size, Decl(iterableTReturnTNext.ts, 26, 38)) + + declare [Symbol.toStringTag]: string; +>[Symbol.toStringTag] : Symbol(MyMap[Symbol.toStringTag], Decl(iterableTReturnTNext.ts, 27, 25)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + + clear(): void { } +>clear : Symbol(MyMap.clear, Decl(iterableTReturnTNext.ts, 28, 41)) + + delete(key: string): boolean { return false; } +>delete : Symbol(MyMap.delete, Decl(iterableTReturnTNext.ts, 30, 21)) +>key : Symbol(key, Decl(iterableTReturnTNext.ts, 31, 11)) + + forEach(callbackfn: (value: number, key: string, map: Map) => void, thisArg?: any): void { } +>forEach : Symbol(MyMap.forEach, Decl(iterableTReturnTNext.ts, 31, 50)) +>callbackfn : Symbol(callbackfn, Decl(iterableTReturnTNext.ts, 32, 12)) +>value : Symbol(value, Decl(iterableTReturnTNext.ts, 32, 25)) +>key : Symbol(key, Decl(iterableTReturnTNext.ts, 32, 39)) +>map : Symbol(map, Decl(iterableTReturnTNext.ts, 32, 52)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>thisArg : Symbol(thisArg, Decl(iterableTReturnTNext.ts, 32, 87)) + + get(key: string): number | undefined { return undefined; } +>get : Symbol(MyMap.get, Decl(iterableTReturnTNext.ts, 32, 112)) +>key : Symbol(key, Decl(iterableTReturnTNext.ts, 33, 8)) +>undefined : Symbol(undefined) + + has(key: string): boolean { return false; } +>has : Symbol(MyMap.has, Decl(iterableTReturnTNext.ts, 33, 62)) +>key : Symbol(key, Decl(iterableTReturnTNext.ts, 34, 8)) + + set(key: string, value: number): this { return this; } +>set : Symbol(MyMap.set, Decl(iterableTReturnTNext.ts, 34, 47)) +>key : Symbol(key, Decl(iterableTReturnTNext.ts, 35, 8)) +>value : Symbol(value, Decl(iterableTReturnTNext.ts, 35, 20)) +>this : Symbol(MyMap, Decl(iterableTReturnTNext.ts, 21, 57)) + + entries(): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } +>entries : Symbol(MyMap.entries, Decl(iterableTReturnTNext.ts, 35, 58)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) + + keys(): IterableIterator { throw new Error("Method not implemented."); } +>keys : Symbol(MyMap.keys, Decl(iterableTReturnTNext.ts, 36, 120)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) + + [Symbol.iterator](): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } +>[Symbol.iterator] : Symbol(MyMap[Symbol.iterator], Decl(iterableTReturnTNext.ts, 37, 107)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) + + // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined` + * values() { +>values : Symbol(MyMap.values, Decl(iterableTReturnTNext.ts, 39, 130)) + + yield* this._values; +>this._values : Symbol(MyMap._values, Decl(iterableTReturnTNext.ts, 25, 36)) +>this : Symbol(MyMap, Decl(iterableTReturnTNext.ts, 21, 57)) +>_values : Symbol(MyMap._values, Decl(iterableTReturnTNext.ts, 25, 36)) + } +} + diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).types b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).types new file mode 100644 index 0000000000000..2f8827d04e15f --- /dev/null +++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).types @@ -0,0 +1,254 @@ +//// [tests/cases/compiler/iterableTReturnTNext.ts] //// + +=== iterableTReturnTNext.ts === +declare const map: Map; +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ + +declare const set: Set; +>set : Set +> : ^^^^^^^^^^^ + +// based on: +// - https://github.com/apollographql/apollo-client/blob/8740f198805a99e01136617c4055d611b92cc231/src/react/hooks/__tests__/useMutation.test.tsx#L2328 +// - https://github.com/continuedev/continue/blob/046bca088a833f8b3620412ff64e4b6f41fbb959/extensions/vscode/src/autocomplete/lsp.ts#L60 +const r1: number = map.values().next().value; // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +>r1 : number +> : ^^^^^^ +>map.values().next().value : number | undefined +> : ^^^^^^^^^^^^^^^^^^ +>map.values().next() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values().next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>value : number | undefined +> : ^^^^^^^^^^^^^^^^^^ + +// based on: https://github.com/gcanti/fp-ts/blob/89a772e95e414acee679f42f56527606f7b61f30/src/Map.ts#L246 +interface Next { + readonly done?: boolean +>done : boolean | undefined +> : ^^^^^^^^^^^^^^^^^^^ + + readonly value: A +>value : A +> : ^ +} +const r2: Next = map.values().next(); // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` +>r2 : Next +> : ^^^^^^^^^^^^ +>map.values().next() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values().next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +// based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175 +async function* source() { yield 1; yield 2; yield 3; } +>source : () => AsyncGenerator<1 | 2 | 3, void, unknown> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield 1 : any +> : ^^^ +>1 : 1 +> : ^ +>yield 2 : any +> : ^^^ +>2 : 2 +> : ^ +>yield 3 : any +> : ^^^ +>3 : 3 +> : ^ + +const doubles = source(); +>doubles : AsyncGenerator<1 | 2 | 3, void, unknown> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>source() : AsyncGenerator<1 | 2 | 3, void, unknown> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>source : () => AsyncGenerator<1 | 2 | 3, void, unknown> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +doubles.return(); +>doubles.return() : Promise> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>doubles.return : (value: void | PromiseLike) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>doubles : AsyncGenerator<1 | 2 | 3, void, unknown> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>return : (value: void | PromiseLike) => Promise> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +// based on: https://github.com/backstage/backstage/blob/85d9346ef11c1c20e4405102b4f5d93afb1292c1/packages/core-app-api/src/routing/RouteTracker.tsx#L62 +const r3: number | undefined = set.values().next().value; +>r3 : number | undefined +> : ^^^^^^^^^^^^^^^^^^ +>set.values().next().value : number | undefined +> : ^^^^^^^^^^^^^^^^^^ +>set.values().next() : IteratorResult +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.values().next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.values() : IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set.values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>set : Set +> : ^^^^^^^^^^^ +>values : () => IterableIterator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>next : (...args: [] | [any]) => IteratorResult +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>value : number | undefined +> : ^^^^^^^^^^^^^^^^^^ + +// based on: https://github.com/microsoft/TypeScript/blob/15f67e0b482faf9f6a3ab9965f3c11196bf3e99b/src/harness/compilerImpl.ts#L77 +class MyMap implements Map { +>MyMap : MyMap +> : ^^^^^ + + declare private _keys: string[]; +>_keys : string[] +> : ^^^^^^^^ + + declare private _values: number[]; +>_values : number[] +> : ^^^^^^^^ + + declare size: number; +>size : number +> : ^^^^^^ + + declare [Symbol.toStringTag]: string; +>[Symbol.toStringTag] : string +> : ^^^^^^ +>Symbol.toStringTag : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>toStringTag : unique symbol +> : ^^^^^^^^^^^^^ + + clear(): void { } +>clear : () => void +> : ^^^^^^ + + delete(key: string): boolean { return false; } +>delete : (key: string) => boolean +> : ^ ^^ ^^^^^ +>key : string +> : ^^^^^^ +>false : false +> : ^^^^^ + + forEach(callbackfn: (value: number, key: string, map: Map) => void, thisArg?: any): void { } +>forEach : (callbackfn: (value: number, key: string, map: Map) => void, thisArg?: any) => void +> : ^ ^^ ^^ ^^^ ^^^^^ +>callbackfn : (value: number, key: string, map: Map) => void +> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^ +>value : number +> : ^^^^^^ +>key : string +> : ^^^^^^ +>map : Map +> : ^^^^^^^^^^^^^^^^^^^ +>thisArg : any +> : ^^^ + + get(key: string): number | undefined { return undefined; } +>get : (key: string) => number | undefined +> : ^ ^^ ^^^^^ +>key : string +> : ^^^^^^ +>undefined : undefined +> : ^^^^^^^^^ + + has(key: string): boolean { return false; } +>has : (key: string) => boolean +> : ^ ^^ ^^^^^ +>key : string +> : ^^^^^^ +>false : false +> : ^^^^^ + + set(key: string, value: number): this { return this; } +>set : (key: string, value: number) => this +> : ^ ^^ ^^ ^^ ^^^^^ +>key : string +> : ^^^^^^ +>value : number +> : ^^^^^^ +>this : this +> : ^^^^ + + entries(): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } +>entries : () => IterableIterator<[string, number], BuiltinIteratorReturn> +> : ^^^^^^ +>new Error("Method not implemented.") : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +>"Method not implemented." : "Method not implemented." +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + keys(): IterableIterator { throw new Error("Method not implemented."); } +>keys : () => IterableIterator +> : ^^^^^^ +>new Error("Method not implemented.") : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +>"Method not implemented." : "Method not implemented." +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + [Symbol.iterator](): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } +>[Symbol.iterator] : () => IterableIterator<[string, number], BuiltinIteratorReturn> +> : ^^^^^^ +>Symbol.iterator : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>iterator : unique symbol +> : ^^^^^^^^^^^^^ +>new Error("Method not implemented.") : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +>"Method not implemented." : "Method not implemented." +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined` + * values() { +>values : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + yield* this._values; +>yield* this._values : undefined +> : ^^^^^^^^^ +>this._values : number[] +> : ^^^^^^^^ +>this : this +> : ^^^^ +>_values : number[] +> : ^^^^^^^^ + } +} + diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt index 524c12bb6b3e0..13723c24505d7 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.errors.txt @@ -1,17 +1,11 @@ -error TS6054: File 'b.js.map' has an unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts', '.cts', '.d.cts', '.mts', '.d.mts'. - The file is in the program because: - Root file specified for compilation -error TS6504: File 'b.js' is a JavaScript file. Did you mean to enable the 'allowJs' option? +error TS6054: File 'b.js.map' has an unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts', '.js', '.jsx', '.cts', '.d.cts', '.cjs', '.mts', '.d.mts', '.mjs'. The file is in the program because: Root file specified for compilation -!!! error TS6054: File 'b.js.map' has an unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts', '.cts', '.d.cts', '.mts', '.d.mts'. +!!! error TS6054: File 'b.js.map' has an unsupported extension. The only supported extensions are '.ts', '.tsx', '.d.ts', '.js', '.jsx', '.cts', '.d.cts', '.cjs', '.mts', '.d.mts', '.mjs'. !!! error TS6054: The file is in the program because: !!! error TS6054: Root file specified for compilation -!!! error TS6504: File 'b.js' is a JavaScript file. Did you mean to enable the 'allowJs' option? -!!! error TS6504: The file is in the program because: -!!! error TS6504: Root file specified for compilation ==== a.ts (0 errors) ==== class c { } diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js index 9fc16e26cd5de..ed21437983493 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js @@ -18,4 +18,8 @@ var c = /** @class */ (function () { } return c; }()); -//# sourceMappingURL=a.js.map \ No newline at end of file +//# sourceMappingURL=a.js.map +//// [b.js] +function bar() { +} +//# sourceMappingURL=b.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map index 2291166790d3f..7cc002476841d 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.js.map @@ -1,2 +1,4 @@ //// [a.js.map] -{"version":3,"file":"a.js","sourceRoot":"","sources":["../a.ts"],"names":[],"mappings":"AAAA;IAAA;IACA,CAAC;IAAD,QAAC;AAAD,CAAC,AADD,IACC"} \ No newline at end of file +{"version":3,"file":"a.js","sourceRoot":"","sources":["../a.ts"],"names":[],"mappings":"AAAA;IAAA;IACA,CAAC;IAAD,QAAC;AAAD,CAAC,AADD,IACC"} +//// [b.js.map] +{"version":3,"file":"b.js","sourceRoot":"","sources":["../b.js"],"names":[],"mappings":"AAAA,SAAS,GAAG;AACZ,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt index d9a7622e95568..a00057db7c49b 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.sourcemap.txt @@ -54,4 +54,35 @@ sourceFile:../a.ts 3 >Emitted(5, 2) Source(1, 1) + SourceIndex(0) 4 >Emitted(5, 6) Source(2, 2) + SourceIndex(0) --- ->>>//# sourceMappingURL=a.js.map \ No newline at end of file +>>>//# sourceMappingURL=a.js.map=================================================================== +JsFile: b.js +mapUrl: b.js.map +sourceRoot: +sources: ../b.js +=================================================================== +------------------------------------------------------------------- +emittedFile:out/b.js +sourceFile:../b.js +------------------------------------------------------------------- +>>>function bar() { +1 > +2 >^^^^^^^^^ +3 > ^^^ +1 > +2 >function +3 > bar +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 10) Source(1, 10) + SourceIndex(0) +3 >Emitted(1, 13) Source(1, 13) + SourceIndex(0) +--- +>>>} +1 > +2 >^ +3 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^-> +1 >() { + > +2 >} +1 >Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 2) Source(2, 2) + SourceIndex(0) +--- +>>>//# sourceMappingURL=b.js.map \ No newline at end of file diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.symbols b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.symbols index 23c4abec429c9..822b9551f655b 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.symbols +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.symbols @@ -5,3 +5,7 @@ class c { >c : Symbol(c, Decl(a.ts, 0, 0)) } +=== b.js === +function bar() { +>bar : Symbol(bar, Decl(b.js, 0, 0)) +} diff --git a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.types b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.types index 2dcd08b59fadd..db36a88424832 100644 --- a/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.types +++ b/tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.types @@ -6,3 +6,8 @@ class c { > : ^ } +=== b.js === +function bar() { +>bar : () => void +> : ^^^^^^^^^^ +} diff --git a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types index 5297e055ec2ac..b64ece233e183 100644 --- a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types +++ b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types @@ -6,14 +6,14 @@ declare let tgt2: number[]; > : ^^^^^^^^ declare let src2: { [K in keyof number[] as Exclude]: (number[])[K] }; ->src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ tgt2 = src2; // Should error ->tgt2 = src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tgt2 = src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >tgt2 : number[] > : ^^^^^^^^ ->src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js index b143900a08085..82e67a1e2c47f 100644 --- a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js +++ b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js @@ -63,7 +63,7 @@ export declare const thing: { fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; - keys: () => IterableIterator; + keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; @@ -172,7 +172,7 @@ mappedTypeWithAsClauseAndLateBoundProperty2.d.ts(27,118): error TS2526: A 'this' fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; - keys: () => IterableIterator; + keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; diff --git a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types index a58dddd838214..17e5229e64b8d 100644 --- a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types +++ b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types @@ -2,11 +2,11 @@ === mappedTypeWithAsClauseAndLateBoundProperty2.ts === export const thing = (null as any as { [K in keyof number[] as Exclude]: (number[])[K] }); ->thing : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(null as any as { [K in keyof number[] as Exclude]: (number[])[K] }) : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->null as any as { [K in keyof number[] as Exclude]: (number[])[K] } : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>thing : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(null as any as { [K in keyof number[] as Exclude]: (number[])[K] }) : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>null as any as { [K in keyof number[] as Exclude]: (number[])[K] } : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray[]): number[]; (...items: (number | ConcatArray)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { (predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; (callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { (predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator; values: () => IterableIterator; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: (callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: (this: A, depth?: D) => FlatArray[]; [Symbol.iterator]: () => IterableIterator; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >null as any : any diff --git a/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types index a9a8e5c0baae5..41859c1f7190e 100644 --- a/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types +++ b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types @@ -221,8 +221,8 @@ class C16 { > : ^^^ async * f() { ->f : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield * []; >yield * [] : any diff --git a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types index c07b24af13d86..145171838a86b 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types +++ b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types @@ -142,8 +142,8 @@ async function * f15() { } === yieldStarWithValueIsOk.ts === async function * f16() { ->f16 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f16 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield * []; >yield * [] : any diff --git a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types index 2eb736f48a6a1..9082a5732d5a0 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types +++ b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types @@ -188,10 +188,10 @@ const f15 = async function * () { }; === yieldStarWithValueIsOk.ts === const f16 = async function * () { ->f16 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield * [];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f16 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield * [];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield * []; >yield * [] : any diff --git a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types index fe75d811809d3..a1c287cfa1fd3 100644 --- a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types +++ b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types @@ -247,14 +247,14 @@ const o15 = { }; === yieldStarWithValueIsOk.ts === const o16 = { ->o16 : { f(): AsyncGenerator; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->{ async * f() { yield * []; }} : { f(): AsyncGenerator; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>o16 : { f(): AsyncGenerator; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ async * f() { yield * []; }} : { f(): AsyncGenerator; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ async * f() { ->f : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield * []; >yield * [] : any diff --git a/tests/baselines/reference/regexMatchAll-esnext.types b/tests/baselines/reference/regexMatchAll-esnext.types index e8048eb9db3a4..222721c3f5927 100644 --- a/tests/baselines/reference/regexMatchAll-esnext.types +++ b/tests/baselines/reference/regexMatchAll-esnext.types @@ -6,8 +6,8 @@ const matches = /\w/g[Symbol.matchAll]("matchAll"); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >/\w/g[Symbol.matchAll]("matchAll") : IterableIterator > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->/\w/g[Symbol.matchAll] : (str: string) => IterableIterator -> : ^ ^^ ^^^^^ +>/\w/g[Symbol.matchAll] : (str: string) => IterableIterator +> : ^ ^^ ^^^^^ >/\w/g : RegExp > : ^^^^^^ >Symbol.matchAll : unique symbol diff --git a/tests/baselines/reference/regexMatchAll.types b/tests/baselines/reference/regexMatchAll.types index acfc292ace79f..53a391b22ee3d 100644 --- a/tests/baselines/reference/regexMatchAll.types +++ b/tests/baselines/reference/regexMatchAll.types @@ -6,8 +6,8 @@ const matches = /\w/g[Symbol.matchAll]("matchAll"); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >/\w/g[Symbol.matchAll]("matchAll") : IterableIterator > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->/\w/g[Symbol.matchAll] : (str: string) => IterableIterator -> : ^ ^^ ^^^^^ +>/\w/g[Symbol.matchAll] : (str: string) => IterableIterator +> : ^ ^^ ^^^^^ >/\w/g : RegExp > : ^^^^^^ >Symbol.matchAll : unique symbol diff --git a/tests/baselines/reference/stringMatchAll.types b/tests/baselines/reference/stringMatchAll.types index a107b9eb3fd5b..12f4460a2e8d6 100644 --- a/tests/baselines/reference/stringMatchAll.types +++ b/tests/baselines/reference/stringMatchAll.types @@ -6,12 +6,12 @@ const matches = "matchAll".matchAll(/\w/g); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >"matchAll".matchAll(/\w/g) : IterableIterator > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->"matchAll".matchAll : (regexp: RegExp) => IterableIterator -> : ^ ^^ ^^^^^ +>"matchAll".matchAll : (regexp: RegExp) => IterableIterator +> : ^ ^^ ^^^^^ >"matchAll" : "matchAll" > : ^^^^^^^^^^ ->matchAll : (regexp: RegExp) => IterableIterator -> : ^ ^^ ^^^^^ +>matchAll : (regexp: RegExp) => IterableIterator +> : ^ ^^ ^^^^^ >/\w/g : RegExp > : ^^^^^^ diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.1.types b/tests/baselines/reference/types.asyncGenerators.es2018.1.types index 2a9d1eb54db4d..2d2f8df98e490 100644 --- a/tests/baselines/reference/types.asyncGenerators.es2018.1.types +++ b/tests/baselines/reference/types.asyncGenerators.es2018.1.types @@ -61,8 +61,8 @@ async function * inferReturnType5() { > : ^ } async function * inferReturnType6() { ->inferReturnType6 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>inferReturnType6 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* [1, 2]; >yield* [1, 2] : any @@ -74,8 +74,8 @@ async function * inferReturnType6() { > : ^ } async function * inferReturnType7() { ->inferReturnType7 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>inferReturnType7 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* [Promise.resolve(1)]; >yield* [Promise.resolve(1)] : any @@ -112,12 +112,11 @@ async function * inferReturnType8() { const assignability1: () => AsyncIterableIterator = async function * () { >assignability1 : () => AsyncIterableIterator > : ^^^^^^ ->async function * () { yield 1;} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield 1;} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield 1; ->yield 1 : undefined -> : ^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ @@ -125,12 +124,11 @@ const assignability1: () => AsyncIterableIterator = async function * () const assignability2: () => AsyncIterableIterator = async function * () { >assignability2 : () => AsyncIterableIterator > : ^^^^^^ ->async function * () { yield Promise.resolve(1);} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield Promise.resolve(1);} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield Promise.resolve(1); ->yield Promise.resolve(1) : undefined -> : ^^^^^^^^^ +>yield Promise.resolve(1) : any >Promise.resolve(1) : Promise > : ^^^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -146,8 +144,8 @@ const assignability2: () => AsyncIterableIterator = async function * () const assignability3: () => AsyncIterableIterator = async function * () { >assignability3 : () => AsyncIterableIterator > : ^^^^^^ ->async function * () { yield* [1, 2];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* [1, 2];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* [1, 2]; >yield* [1, 2] : any @@ -162,8 +160,8 @@ const assignability3: () => AsyncIterableIterator = async function * () const assignability4: () => AsyncIterableIterator = async function * () { >assignability4 : () => AsyncIterableIterator > : ^^^^^^ ->async function * () { yield* [Promise.resolve(1)];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* [Promise.resolve(1)];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* [Promise.resolve(1)]; >yield* [Promise.resolve(1)] : any @@ -184,20 +182,19 @@ const assignability4: () => AsyncIterableIterator = async function * () const assignability5: () => AsyncIterableIterator = async function * () { >assignability5 : () => AsyncIterableIterator > : ^^^^^^ ->async function * () { yield* (async function * () { yield 1; })();} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* (async function * () { yield 1; })();} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* (async function * () { yield 1; })(); >yield* (async function * () { yield 1; })() : void > : ^^^^ ->(async function * () { yield 1; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield 1; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield 1; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield 1 : undefined -> : ^^^^^^^^^ +>(async function * () { yield 1; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield 1; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield 1; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ @@ -205,12 +202,11 @@ const assignability5: () => AsyncIterableIterator = async function * () const assignability6: () => AsyncIterable = async function * () { >assignability6 : () => AsyncIterable > : ^^^^^^ ->async function * () { yield 1;} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield 1;} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield 1; ->yield 1 : undefined -> : ^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ @@ -218,12 +214,11 @@ const assignability6: () => AsyncIterable = async function * () { const assignability7: () => AsyncIterable = async function * () { >assignability7 : () => AsyncIterable > : ^^^^^^ ->async function * () { yield Promise.resolve(1);} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield Promise.resolve(1);} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield Promise.resolve(1); ->yield Promise.resolve(1) : undefined -> : ^^^^^^^^^ +>yield Promise.resolve(1) : any >Promise.resolve(1) : Promise > : ^^^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -239,8 +234,8 @@ const assignability7: () => AsyncIterable = async function * () { const assignability8: () => AsyncIterable = async function * () { >assignability8 : () => AsyncIterable > : ^^^^^^ ->async function * () { yield* [1, 2];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* [1, 2];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* [1, 2]; >yield* [1, 2] : any @@ -255,8 +250,8 @@ const assignability8: () => AsyncIterable = async function * () { const assignability9: () => AsyncIterable = async function * () { >assignability9 : () => AsyncIterable > : ^^^^^^ ->async function * () { yield* [Promise.resolve(1)];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* [Promise.resolve(1)];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* [Promise.resolve(1)]; >yield* [Promise.resolve(1)] : any @@ -277,20 +272,19 @@ const assignability9: () => AsyncIterable = async function * () { const assignability10: () => AsyncIterable = async function * () { >assignability10 : () => AsyncIterable > : ^^^^^^ ->async function * () { yield* (async function * () { yield 1; })();} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* (async function * () { yield 1; })();} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* (async function * () { yield 1; })(); >yield* (async function * () { yield 1; })() : void > : ^^^^ ->(async function * () { yield 1; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield 1; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield 1; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield 1 : undefined -> : ^^^^^^^^^ +>(async function * () { yield 1; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield 1; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield 1; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ @@ -298,12 +292,11 @@ const assignability10: () => AsyncIterable = async function * () { const assignability11: () => AsyncIterator = async function * () { >assignability11 : () => AsyncIterator > : ^^^^^^ ->async function * () { yield 1;} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield 1;} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield 1; ->yield 1 : undefined -> : ^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ @@ -311,12 +304,11 @@ const assignability11: () => AsyncIterator = async function * () { const assignability12: () => AsyncIterator = async function * () { >assignability12 : () => AsyncIterator > : ^^^^^^ ->async function * () { yield Promise.resolve(1);} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield Promise.resolve(1);} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield Promise.resolve(1); ->yield Promise.resolve(1) : undefined -> : ^^^^^^^^^ +>yield Promise.resolve(1) : any >Promise.resolve(1) : Promise > : ^^^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -332,8 +324,8 @@ const assignability12: () => AsyncIterator = async function * () { const assignability13: () => AsyncIterator = async function * () { >assignability13 : () => AsyncIterator > : ^^^^^^ ->async function * () { yield* [1, 2];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* [1, 2];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* [1, 2]; >yield* [1, 2] : any @@ -348,8 +340,8 @@ const assignability13: () => AsyncIterator = async function * () { const assignability14: () => AsyncIterator = async function * () { >assignability14 : () => AsyncIterator > : ^^^^^^ ->async function * () { yield* [Promise.resolve(1)];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* [Promise.resolve(1)];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* [Promise.resolve(1)]; >yield* [Promise.resolve(1)] : any @@ -370,20 +362,19 @@ const assignability14: () => AsyncIterator = async function * () { const assignability15: () => AsyncIterator = async function * () { >assignability15 : () => AsyncIterator > : ^^^^^^ ->async function * () { yield* (async function * () { yield 1; })();} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* (async function * () { yield 1; })();} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* (async function * () { yield 1; })(); >yield* (async function * () { yield 1; })() : void > : ^^^^ ->(async function * () { yield 1; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield 1; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield 1; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield 1 : undefined -> : ^^^^^^^^^ +>(async function * () { yield 1; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield 1; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield 1; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ @@ -393,8 +384,7 @@ async function * explicitReturnType1(): AsyncIterableIterator { > : ^^^^^^ yield 1; ->yield 1 : undefined -> : ^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ } @@ -403,8 +393,7 @@ async function * explicitReturnType2(): AsyncIterableIterator { > : ^^^^^^ yield Promise.resolve(1); ->yield Promise.resolve(1) : undefined -> : ^^^^^^^^^ +>yield Promise.resolve(1) : any >Promise.resolve(1) : Promise > : ^^^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -455,14 +444,13 @@ async function * explicitReturnType5(): AsyncIterableIterator { yield* (async function * () { yield 1; })(); >yield* (async function * () { yield 1; })() : void > : ^^^^ ->(async function * () { yield 1; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield 1; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield 1; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield 1 : undefined -> : ^^^^^^^^^ +>(async function * () { yield 1; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield 1; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield 1; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ } @@ -471,8 +459,7 @@ async function * explicitReturnType6(): AsyncIterable { > : ^^^^^^ yield 1; ->yield 1 : undefined -> : ^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ } @@ -481,8 +468,7 @@ async function * explicitReturnType7(): AsyncIterable { > : ^^^^^^ yield Promise.resolve(1); ->yield Promise.resolve(1) : undefined -> : ^^^^^^^^^ +>yield Promise.resolve(1) : any >Promise.resolve(1) : Promise > : ^^^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -533,14 +519,13 @@ async function * explicitReturnType10(): AsyncIterable { yield* (async function * () { yield 1; })(); >yield* (async function * () { yield 1; })() : void > : ^^^^ ->(async function * () { yield 1; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield 1; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield 1; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield 1 : undefined -> : ^^^^^^^^^ +>(async function * () { yield 1; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield 1; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield 1; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ } @@ -549,8 +534,7 @@ async function * explicitReturnType11(): AsyncIterator { > : ^^^^^^ yield 1; ->yield 1 : undefined -> : ^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ } @@ -559,8 +543,7 @@ async function * explicitReturnType12(): AsyncIterator { > : ^^^^^^ yield Promise.resolve(1); ->yield Promise.resolve(1) : undefined -> : ^^^^^^^^^ +>yield Promise.resolve(1) : any >Promise.resolve(1) : Promise > : ^^^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -611,14 +594,13 @@ async function * explicitReturnType15(): AsyncIterator { yield* (async function * () { yield 1; })(); >yield* (async function * () { yield 1; })() : void > : ^^^^ ->(async function * () { yield 1; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield 1; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield 1; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield 1 : undefined -> : ^^^^^^^^^ +>(async function * () { yield 1; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield 1; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield 1; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield 1 : any >1 : 1 > : ^ } diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt index 1efc4e535a3a5..4aa4491e4234b 100644 --- a/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt +++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt @@ -1,71 +1,71 @@ types.asyncGenerators.es2018.2.ts(2,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. types.asyncGenerators.es2018.2.ts(8,12): error TS2504: Type 'Promise' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -types.asyncGenerators.es2018.2.ts(10,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. - Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. +types.asyncGenerators.es2018.2.ts(10,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. + Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. The types returned by 'next(...)' are incompatible between these types. Type 'Promise>' is not assignable to type 'Promise>'. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult'. Type 'string' is not assignable to type 'number'. -types.asyncGenerators.es2018.2.ts(13,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. - Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. +types.asyncGenerators.es2018.2.ts(13,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. + Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. The types returned by 'next(...)' are incompatible between these types. Type 'Promise>' is not assignable to type 'Promise>'. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult'. Type 'string' is not assignable to type 'number'. -types.asyncGenerators.es2018.2.ts(16,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. - Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. +types.asyncGenerators.es2018.2.ts(16,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. + Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. The types returned by 'next(...)' are incompatible between these types. Type 'Promise>' is not assignable to type 'Promise>'. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult'. Type 'string' is not assignable to type 'number'. -types.asyncGenerators.es2018.2.ts(19,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. - Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. +types.asyncGenerators.es2018.2.ts(19,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. + Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types. Type 'Promise>' is not assignable to type 'Promise>'. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult'. Type 'string' is not assignable to type 'number'. -types.asyncGenerators.es2018.2.ts(22,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. - Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. +types.asyncGenerators.es2018.2.ts(22,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. + Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types. Type 'Promise>' is not assignable to type 'Promise>'. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult'. Type 'string' is not assignable to type 'number'. -types.asyncGenerators.es2018.2.ts(25,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. - Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. +types.asyncGenerators.es2018.2.ts(25,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. + Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types. Type 'Promise>' is not assignable to type 'Promise>'. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult'. Type 'string' is not assignable to type 'number'. -types.asyncGenerators.es2018.2.ts(28,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. - Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. +types.asyncGenerators.es2018.2.ts(28,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. + Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. The types returned by 'next(...)' are incompatible between these types. Type 'Promise>' is not assignable to type 'Promise>'. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult'. Type 'string' is not assignable to type 'number'. -types.asyncGenerators.es2018.2.ts(31,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. - Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. +types.asyncGenerators.es2018.2.ts(31,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. + Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. The types returned by 'next(...)' are incompatible between these types. Type 'Promise>' is not assignable to type 'Promise>'. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult'. Type 'string' is not assignable to type 'number'. -types.asyncGenerators.es2018.2.ts(34,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. - Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. +types.asyncGenerators.es2018.2.ts(34,7): error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. + Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. The types returned by 'next(...)' are incompatible between these types. Type 'Promise>' is not assignable to type 'Promise>'. Type 'IteratorResult' is not assignable to type 'IteratorResult'. @@ -81,9 +81,9 @@ types.asyncGenerators.es2018.2.ts(53,12): error TS2322: Type 'string' is not ass types.asyncGenerators.es2018.2.ts(56,11): error TS2322: Type 'string' is not assignable to type 'number'. types.asyncGenerators.es2018.2.ts(59,12): error TS2322: Type 'string' is not assignable to type 'number'. types.asyncGenerators.es2018.2.ts(62,12): error TS2322: Type 'string' is not assignable to type 'number'. -types.asyncGenerators.es2018.2.ts(64,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncGenerator' but required in type 'IterableIterator'. +types.asyncGenerators.es2018.2.ts(64,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncGenerator' but required in type 'IterableIterator'. types.asyncGenerators.es2018.2.ts(67,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncGenerator' but required in type 'Iterable'. -types.asyncGenerators.es2018.2.ts(70,42): error TS2322: Type 'AsyncGenerator' is not assignable to type 'Iterator'. +types.asyncGenerators.es2018.2.ts(70,42): error TS2322: Type 'AsyncGenerator' is not assignable to type 'Iterator'. The types returned by 'next(...)' are incompatible between these types. Type 'Promise>' is not assignable to type 'IteratorResult'. types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. @@ -106,8 +106,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[ } const assignability1: () => AsyncIterableIterator = async function * () { ~~~~~~~~~~~~~~ -!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. -!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. +!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. +!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. !!! error TS2322: The types returned by 'next(...)' are incompatible between these types. !!! error TS2322: Type 'Promise>' is not assignable to type 'Promise>'. !!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. @@ -118,8 +118,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[ }; const assignability2: () => AsyncIterableIterator = async function * () { ~~~~~~~~~~~~~~ -!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. -!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. +!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. +!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. !!! error TS2322: The types returned by 'next(...)' are incompatible between these types. !!! error TS2322: Type 'Promise>' is not assignable to type 'Promise>'. !!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. @@ -130,8 +130,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[ }; const assignability3: () => AsyncIterableIterator = async function * () { ~~~~~~~~~~~~~~ -!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. -!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. +!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterableIterator'. +!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterableIterator' are incompatible. !!! error TS2322: The types returned by 'next(...)' are incompatible between these types. !!! error TS2322: Type 'Promise>' is not assignable to type 'Promise>'. !!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. @@ -142,8 +142,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[ }; const assignability4: () => AsyncIterable = async function * () { ~~~~~~~~~~~~~~ -!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. -!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. +!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. +!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. !!! error TS2322: The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types. !!! error TS2322: Type 'Promise>' is not assignable to type 'Promise>'. !!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. @@ -154,8 +154,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[ }; const assignability5: () => AsyncIterable = async function * () { ~~~~~~~~~~~~~~ -!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. -!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. +!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. +!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. !!! error TS2322: The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types. !!! error TS2322: Type 'Promise>' is not assignable to type 'Promise>'. !!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. @@ -166,8 +166,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[ }; const assignability6: () => AsyncIterable = async function * () { ~~~~~~~~~~~~~~ -!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. -!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. +!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterable'. +!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterable' are incompatible. !!! error TS2322: The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types. !!! error TS2322: Type 'Promise>' is not assignable to type 'Promise>'. !!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. @@ -178,8 +178,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[ }; const assignability7: () => AsyncIterator = async function * () { ~~~~~~~~~~~~~~ -!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. -!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. +!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. +!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. !!! error TS2322: The types returned by 'next(...)' are incompatible between these types. !!! error TS2322: Type 'Promise>' is not assignable to type 'Promise>'. !!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. @@ -190,8 +190,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[ }; const assignability8: () => AsyncIterator = async function * () { ~~~~~~~~~~~~~~ -!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. -!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. +!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. +!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. !!! error TS2322: The types returned by 'next(...)' are incompatible between these types. !!! error TS2322: Type 'Promise>' is not assignable to type 'Promise>'. !!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. @@ -202,8 +202,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[ }; const assignability9: () => AsyncIterator = async function * () { ~~~~~~~~~~~~~~ -!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. -!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. +!!! error TS2322: Type '() => AsyncGenerator' is not assignable to type '() => AsyncIterator'. +!!! error TS2322: Call signature return types 'AsyncGenerator' and 'AsyncIterator' are incompatible. !!! error TS2322: The types returned by 'next(...)' are incompatible between these types. !!! error TS2322: Type 'Promise>' is not assignable to type 'Promise>'. !!! error TS2322: Type 'IteratorResult' is not assignable to type 'IteratorResult'. @@ -259,7 +259,7 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[ } async function * explicitReturnType10(): IterableIterator { ~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncGenerator' but required in type 'IterableIterator'. +!!! error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncGenerator' but required in type 'IterableIterator'. !!! related TS2728 lib.es2015.iterable.d.ts:--:--: '[Symbol.iterator]' is declared here. yield 1; } @@ -271,7 +271,7 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[ } async function * explicitReturnType12(): Iterator { ~~~~~~~~~~~~~~~~ -!!! error TS2322: Type 'AsyncGenerator' is not assignable to type 'Iterator'. +!!! error TS2322: Type 'AsyncGenerator' is not assignable to type 'Iterator'. !!! error TS2322: The types returned by 'next(...)' are incompatible between these types. !!! error TS2322: Type 'Promise>' is not assignable to type 'IteratorResult'. yield 1; diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.types b/tests/baselines/reference/types.asyncGenerators.es2018.2.types index 41275777ea664..1f65af986e913 100644 --- a/tests/baselines/reference/types.asyncGenerators.es2018.2.types +++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.types @@ -48,12 +48,12 @@ async function * inferReturnType3() { const assignability1: () => AsyncIterableIterator = async function * () { >assignability1 : () => AsyncIterableIterator > : ^^^^^^ ->async function * () { yield "a";} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield "a";} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield "a"; ->yield "a" : undefined -> : ^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ @@ -61,8 +61,8 @@ const assignability1: () => AsyncIterableIterator = async function * () const assignability2: () => AsyncIterableIterator = async function * () { >assignability2 : () => AsyncIterableIterator > : ^^^^^^ ->async function * () { yield* ["a", "b"];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* ["a", "b"];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* ["a", "b"]; >yield* ["a", "b"] : any @@ -78,20 +78,20 @@ const assignability2: () => AsyncIterableIterator = async function * () const assignability3: () => AsyncIterableIterator = async function * () { >assignability3 : () => AsyncIterableIterator > : ^^^^^^ ->async function * () { yield* (async function * () { yield "a"; })();} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* (async function * () { yield "a"; })();} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* (async function * () { yield "a"; })(); >yield* (async function * () { yield "a"; })() : void > : ^^^^ ->(async function * () { yield "a"; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield "a"; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield "a"; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield "a" : undefined -> : ^^^^^^^^^ +>(async function * () { yield "a"; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield "a"; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield "a"; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ @@ -99,12 +99,12 @@ const assignability3: () => AsyncIterableIterator = async function * () const assignability4: () => AsyncIterable = async function * () { >assignability4 : () => AsyncIterable > : ^^^^^^ ->async function * () { yield "a";} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield "a";} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield "a"; ->yield "a" : undefined -> : ^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ @@ -112,8 +112,8 @@ const assignability4: () => AsyncIterable = async function * () { const assignability5: () => AsyncIterable = async function * () { >assignability5 : () => AsyncIterable > : ^^^^^^ ->async function * () { yield* ["a", "b"];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* ["a", "b"];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* ["a", "b"]; >yield* ["a", "b"] : any @@ -129,20 +129,20 @@ const assignability5: () => AsyncIterable = async function * () { const assignability6: () => AsyncIterable = async function * () { >assignability6 : () => AsyncIterable > : ^^^^^^ ->async function * () { yield* (async function * () { yield "a"; })();} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* (async function * () { yield "a"; })();} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* (async function * () { yield "a"; })(); >yield* (async function * () { yield "a"; })() : void > : ^^^^ ->(async function * () { yield "a"; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield "a"; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield "a"; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield "a" : undefined -> : ^^^^^^^^^ +>(async function * () { yield "a"; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield "a"; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield "a"; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ @@ -150,12 +150,12 @@ const assignability6: () => AsyncIterable = async function * () { const assignability7: () => AsyncIterator = async function * () { >assignability7 : () => AsyncIterator > : ^^^^^^ ->async function * () { yield "a";} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield "a";} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield "a"; ->yield "a" : undefined -> : ^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ @@ -163,8 +163,8 @@ const assignability7: () => AsyncIterator = async function * () { const assignability8: () => AsyncIterator = async function * () { >assignability8 : () => AsyncIterator > : ^^^^^^ ->async function * () { yield* ["a", "b"];} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* ["a", "b"];} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* ["a", "b"]; >yield* ["a", "b"] : any @@ -180,20 +180,20 @@ const assignability8: () => AsyncIterator = async function * () { const assignability9: () => AsyncIterator = async function * () { >assignability9 : () => AsyncIterator > : ^^^^^^ ->async function * () { yield* (async function * () { yield "a"; })();} : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield* (async function * () { yield "a"; })();} : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield* (async function * () { yield "a"; })(); >yield* (async function * () { yield "a"; })() : void > : ^^^^ ->(async function * () { yield "a"; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield "a"; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield "a"; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield "a" : undefined -> : ^^^^^^^^^ +>(async function * () { yield "a"; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield "a"; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield "a"; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ @@ -203,8 +203,8 @@ async function * explicitReturnType1(): AsyncIterableIterator { > : ^^^^^^ yield "a"; ->yield "a" : undefined -> : ^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ } @@ -229,14 +229,14 @@ async function * explicitReturnType3(): AsyncIterableIterator { yield* (async function * () { yield "a"; })(); >yield* (async function * () { yield "a"; })() : void > : ^^^^ ->(async function * () { yield "a"; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield "a"; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield "a"; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield "a" : undefined -> : ^^^^^^^^^ +>(async function * () { yield "a"; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield "a"; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield "a"; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ } @@ -245,8 +245,8 @@ async function * explicitReturnType4(): AsyncIterable { > : ^^^^^^ yield "a"; ->yield "a" : undefined -> : ^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ } @@ -271,14 +271,14 @@ async function * explicitReturnType6(): AsyncIterable { yield* (async function * () { yield "a"; })(); >yield* (async function * () { yield "a"; })() : void > : ^^^^ ->(async function * () { yield "a"; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield "a"; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield "a"; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield "a" : undefined -> : ^^^^^^^^^ +>(async function * () { yield "a"; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield "a"; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield "a"; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ } @@ -287,8 +287,8 @@ async function * explicitReturnType7(): AsyncIterator { > : ^^^^^^ yield "a"; ->yield "a" : undefined -> : ^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ } @@ -313,14 +313,14 @@ async function * explicitReturnType9(): AsyncIterator { yield* (async function * () { yield "a"; })(); >yield* (async function * () { yield "a"; })() : void > : ^^^^ ->(async function * () { yield "a"; })() : AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(async function * () { yield "a"; }) : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->async function * () { yield "a"; } : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->yield "a" : undefined -> : ^^^^^^^^^ +>(async function * () { yield "a"; })() : AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(async function * () { yield "a"; }) : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async function * () { yield "a"; } : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>yield "a" : any +> : ^^^ >"a" : "a" > : ^^^ } @@ -329,8 +329,8 @@ async function * explicitReturnType10(): IterableIterator { > : ^^^^^^ yield 1; ->yield 1 : undefined -> : ^^^^^^^^^ +>yield 1 : any +> : ^^^ >1 : 1 > : ^ } @@ -349,8 +349,8 @@ async function * explicitReturnType12(): Iterator { > : ^^^^^^ yield 1; ->yield 1 : undefined -> : ^^^^^^^^^ +>yield 1 : any +> : ^^^ >1 : 1 > : ^ } diff --git a/tests/baselines/reference/types.forAwait.es2018.2.errors.txt b/tests/baselines/reference/types.forAwait.es2018.2.errors.txt index 77422b5d728da..b0635928d4860 100644 --- a/tests/baselines/reference/types.forAwait.es2018.2.errors.txt +++ b/tests/baselines/reference/types.forAwait.es2018.2.errors.txt @@ -31,10 +31,12 @@ types.forAwait.es2018.2.ts(16,15): error TS2488: Type 'AsyncIterable' mu for (const x of asyncIterable) { ~~~~~~~~~~~~~ !!! error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. +!!! related TS2773 types.forAwait.es2018.2.ts:14:21: Did you forget to use 'await'? } for (y of asyncIterable) { ~~~~~~~~~~~~~ !!! error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. +!!! related TS2773 types.forAwait.es2018.2.ts:16:15: Did you forget to use 'await'? } } \ No newline at end of file diff --git a/tests/baselines/reference/uniqueSymbols.types b/tests/baselines/reference/uniqueSymbols.types index 1ee2fbcaff4e2..c9aa5b7952203 100644 --- a/tests/baselines/reference/uniqueSymbols.types +++ b/tests/baselines/reference/uniqueSymbols.types @@ -195,8 +195,7 @@ function* genFuncYieldConstCallWithTypeQuery(): IterableIterator : ^^^^^^ >constCall : unique symbol > : ^^^^^^^^^^^^^ ->yield constCall : undefined -> : ^^^^^^^^^ +>yield constCall : any >constCall : unique symbol > : ^^^^^^^^^^^^^ @@ -1304,8 +1303,8 @@ interface Context { const o3: Context = { >o3 : Context > : ^^^^^^^ ->{ method1() { return s; // return type should not widen due to contextual type }, async method2() { return s; // return type should not widen due to contextual type }, async * method3() { yield s; // yield type should not widen due to contextual type }, * method4() { yield s; // yield type should not widen due to contextual type }, method5(p = s) { // parameter should not widen due to contextual type return p; },} : { method1(): unique symbol; method2(): Promise; method3(): AsyncGenerator; method4(): Generator; method5(p?: unique symbol): unique symbol; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ method1() { return s; // return type should not widen due to contextual type }, async method2() { return s; // return type should not widen due to contextual type }, async * method3() { yield s; // yield type should not widen due to contextual type }, * method4() { yield s; // yield type should not widen due to contextual type }, method5(p = s) { // parameter should not widen due to contextual type return p; },} : { method1(): unique symbol; method2(): Promise; method3(): AsyncGenerator; method4(): Generator; method5(p?: unique symbol): unique symbol; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ method1() { >method1 : () => unique symbol @@ -1326,23 +1325,21 @@ const o3: Context = { }, async * method3() { ->method3 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>method3 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield s; // yield type should not widen due to contextual type ->yield s : undefined -> : ^^^^^^^^^ +>yield s : any >s : unique symbol > : ^^^^^^^^^^^^^ }, * method4() { ->method4 : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>method4 : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield s; // yield type should not widen due to contextual type ->yield s : undefined -> : ^^^^^^^^^ +>yield s : any >s : unique symbol > : ^^^^^^^^^^^^^ diff --git a/tests/baselines/reference/uniqueSymbolsDeclarations.types b/tests/baselines/reference/uniqueSymbolsDeclarations.types index c8bd68e1b3b63..fadf33c1b43cf 100644 --- a/tests/baselines/reference/uniqueSymbolsDeclarations.types +++ b/tests/baselines/reference/uniqueSymbolsDeclarations.types @@ -186,8 +186,7 @@ function* genFuncYieldConstCallWithTypeQuery(): IterableIterator : ^^^^^^ >constCall : unique symbol > : ^^^^^^^^^^^^^ ->yield constCall : undefined -> : ^^^^^^^^^ +>yield constCall : any >constCall : unique symbol > : ^^^^^^^^^^^^^ @@ -1295,8 +1294,8 @@ interface Context { const o4: Context = { >o4 : Context > : ^^^^^^^ ->{ method1() { return s; // return type should not widen due to contextual type }, async method2() { return s; // return type should not widen due to contextual type }, async * method3() { yield s; // yield type should not widen due to contextual type }, * method4() { yield s; // yield type should not widen due to contextual type }, method5(p = s) { // parameter should not widen due to contextual type return p; }} : { method1(): unique symbol; method2(): Promise; method3(): AsyncGenerator; method4(): Generator; method5(p?: unique symbol): unique symbol; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ method1() { return s; // return type should not widen due to contextual type }, async method2() { return s; // return type should not widen due to contextual type }, async * method3() { yield s; // yield type should not widen due to contextual type }, * method4() { yield s; // yield type should not widen due to contextual type }, method5(p = s) { // parameter should not widen due to contextual type return p; }} : { method1(): unique symbol; method2(): Promise; method3(): AsyncGenerator; method4(): Generator; method5(p?: unique symbol): unique symbol; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ method1() { >method1 : () => unique symbol @@ -1317,23 +1316,21 @@ const o4: Context = { }, async * method3() { ->method3 : () => AsyncGenerator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>method3 : () => AsyncGenerator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield s; // yield type should not widen due to contextual type ->yield s : undefined -> : ^^^^^^^^^ +>yield s : any >s : unique symbol > : ^^^^^^^^^^^^^ }, * method4() { ->method4 : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>method4 : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ yield s; // yield type should not widen due to contextual type ->yield s : undefined -> : ^^^^^^^^^ +>yield s : any >s : unique symbol > : ^^^^^^^^^^^^^ diff --git a/tests/baselines/reference/yieldExpression1.types b/tests/baselines/reference/yieldExpression1.types index 38715c1dd92a9..1544635e065a8 100644 --- a/tests/baselines/reference/yieldExpression1.types +++ b/tests/baselines/reference/yieldExpression1.types @@ -21,12 +21,12 @@ function* b(): IterableIterator { > : ^^^^^^ yield; ->yield : undefined -> : ^^^^^^^^^ +>yield : any +> : ^^^ yield 0; ->yield 0 : undefined -> : ^^^^^^^^^ +>yield 0 : any +> : ^^^ >0 : 0 > : ^ } diff --git a/tests/baselines/reference/yieldExpressionInnerCommentEmit.types b/tests/baselines/reference/yieldExpressionInnerCommentEmit.types index f6ea97325fd61..bba612bd5c756 100644 --- a/tests/baselines/reference/yieldExpressionInnerCommentEmit.types +++ b/tests/baselines/reference/yieldExpressionInnerCommentEmit.types @@ -2,8 +2,8 @@ === yieldExpressionInnerCommentEmit.ts === function * foo2() { ->foo2 : () => Generator -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>foo2 : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ /*comment1*/ yield 1; >yield 1 : any diff --git a/tests/cases/compiler/customAsyncIterator.ts b/tests/cases/compiler/customAsyncIterator.ts index 3f80b4ef2a96c..c5c6c5f9cc5fe 100644 --- a/tests/cases/compiler/customAsyncIterator.ts +++ b/tests/cases/compiler/customAsyncIterator.ts @@ -2,7 +2,7 @@ // @useDefineForClassFields: false // GH: https://github.com/microsoft/TypeScript/issues/33239 -class ConstantIterator implements AsyncIterator { +class ConstantIterator implements AsyncIterator { constructor(private constant: T) { } async next(value?: T): Promise> { diff --git a/tests/cases/compiler/discriminateWithOptionalProperty2.ts b/tests/cases/compiler/discriminateWithOptionalProperty2.ts index d740bcd7ce70d..a8b36cb497489 100644 --- a/tests/cases/compiler/discriminateWithOptionalProperty2.ts +++ b/tests/cases/compiler/discriminateWithOptionalProperty2.ts @@ -8,7 +8,7 @@ type PromiseOrValue = Promise | T; function mapAsyncIterable( - iterable: AsyncGenerator | AsyncIterable, + iterable: AsyncGenerator | AsyncIterable, callback: (value: T) => PromiseOrValue, ): AsyncGenerator { const iterator = iterable[Symbol.asyncIterator](); diff --git a/tests/cases/compiler/isolatedDeclarationsStrictBuiltinIteratorReturn.ts b/tests/cases/compiler/isolatedDeclarationsStrictBuiltinIteratorReturn.ts new file mode 100644 index 0000000000000..8da68083d483a --- /dev/null +++ b/tests/cases/compiler/isolatedDeclarationsStrictBuiltinIteratorReturn.ts @@ -0,0 +1,53 @@ +// @isolatedDeclarations: * +// @strictBuiltinIteratorReturn: * +// @declaration: true +// @target: esnext +// @noTypesAndSymbols: true + +declare let x1: Iterable; +declare let x2: Iterable; +declare let x3: Iterable; +declare let x4: Iterable; +declare let x5: Iterable; +declare let x6: Iterable; +declare let x7: Iterable; + +declare let x8: IterableIterator; +declare let x9: IterableIterator; +declare let x10: IterableIterator; +declare let x11: IterableIterator; +declare let x12: IterableIterator; +declare let x13: IterableIterator; +declare let x14: IterableIterator; + +declare function f1(): Iterable; +declare function f2(): Iterable; +declare function f3(): Iterable; +declare function f4(): Iterable; +declare function f5(): Iterable; +declare function f6(): Iterable; +declare function f7(): Iterable; + +declare function f8(): IterableIterator; +declare function f9(): IterableIterator; +declare function f10(): IterableIterator; +declare function f11(): IterableIterator; +declare function f12(): IterableIterator; +declare function f13(): IterableIterator; +declare function f14(): IterableIterator; + +const a1 = (): Iterable => null!; +const a2 = (): Iterable => null!; +const a3 = (): Iterable => null!; +const a4 = (): Iterable => null!; +const a5 = (): Iterable => null!; +const a6 = (): Iterable => null!; +const a7 = (): Iterable => null!; + +const a8 = (): IterableIterator => null!; +const a9 = (): IterableIterator => null!; +const a10 = (): IterableIterator => null!; +const a11 = (): IterableIterator => null!; +const a12 = (): IterableIterator => null!; +const a13 = (): IterableIterator => null!; +const a14 = (): IterableIterator => null!; \ No newline at end of file diff --git a/tests/cases/compiler/iterableTReturnTNext.ts b/tests/cases/compiler/iterableTReturnTNext.ts new file mode 100644 index 0000000000000..9e24354b88d66 --- /dev/null +++ b/tests/cases/compiler/iterableTReturnTNext.ts @@ -0,0 +1,50 @@ +// @target: esnext +// @strict: true +// @strictBuiltinIteratorReturn: * + +declare const map: Map; +declare const set: Set; + +// based on: +// - https://github.com/apollographql/apollo-client/blob/8740f198805a99e01136617c4055d611b92cc231/src/react/hooks/__tests__/useMutation.test.tsx#L2328 +// - https://github.com/continuedev/continue/blob/046bca088a833f8b3620412ff64e4b6f41fbb959/extensions/vscode/src/autocomplete/lsp.ts#L60 +const r1: number = map.values().next().value; // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` + +// based on: https://github.com/gcanti/fp-ts/blob/89a772e95e414acee679f42f56527606f7b61f30/src/Map.ts#L246 +interface Next { + readonly done?: boolean + readonly value: A +} +const r2: Next = map.values().next(); // error when strictBuiltinIteratorReturn is true as result is potentially `{ done: true, value: undefined }` + +// based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175 +async function* source() { yield 1; yield 2; yield 3; } +const doubles = source(); +doubles.return(); + +// based on: https://github.com/backstage/backstage/blob/85d9346ef11c1c20e4405102b4f5d93afb1292c1/packages/core-app-api/src/routing/RouteTracker.tsx#L62 +const r3: number | undefined = set.values().next().value; + +// based on: https://github.com/microsoft/TypeScript/blob/15f67e0b482faf9f6a3ab9965f3c11196bf3e99b/src/harness/compilerImpl.ts#L77 +class MyMap implements Map { + declare private _keys: string[]; + declare private _values: number[]; + declare size: number; + declare [Symbol.toStringTag]: string; + + clear(): void { } + delete(key: string): boolean { return false; } + forEach(callbackfn: (value: number, key: string, map: Map) => void, thisArg?: any): void { } + get(key: string): number | undefined { return undefined; } + has(key: string): boolean { return false; } + set(key: string, value: number): this { return this; } + entries(): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } + keys(): IterableIterator { throw new Error("Method not implemented."); } + + [Symbol.iterator](): IterableIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); } + + // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined` + * values() { + yield* this._values; + } +} diff --git a/tests/cases/compiler/jsFileCompilationWithMapFileAsJsWithOutDir.ts b/tests/cases/compiler/jsFileCompilationWithMapFileAsJsWithOutDir.ts index 9e39ae274b4fa..0f860626676c0 100644 --- a/tests/cases/compiler/jsFileCompilationWithMapFileAsJsWithOutDir.ts +++ b/tests/cases/compiler/jsFileCompilationWithMapFileAsJsWithOutDir.ts @@ -1,4 +1,4 @@ -// @allowJs: true,map +// @allowJs: true // @sourcemap: true // @outdir: out diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts index e77ec3d911c66..14d90f47a8658 100644 --- a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts +++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts @@ -1,4 +1,4 @@ //@target: ES6 -function* g(): IterableIterator { +function* g(): IterableIterator { return 0; } \ No newline at end of file diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts index 6f602a239819c..fa45b8c39ba7f 100644 --- a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts +++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts @@ -1,4 +1,4 @@ //@target: ES6 -function* g(): IterableIterator { +function* g(): IterableIterator { return ""; } \ No newline at end of file diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts index a21d9e8ab63e7..d9cce1a5eafc5 100644 --- a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts +++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts @@ -1,5 +1,5 @@ //@target: ES6 -function* g(): IterableIterator { +function* g(): IterableIterator { yield 0; return ""; } \ No newline at end of file diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts index 334d21e38331c..f37e13eddd910 100644 --- a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts +++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts @@ -1,5 +1,5 @@ //@target: ES6 -function* g(): IterableIterator<(x: string) => number> { +function* g(): IterableIterator<(x: string) => number, (x: string) => number> { yield x => x.length; yield *[x => x.length]; return x => x.length; diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck62.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck62.ts index 2f30fe9d90257..ee85d45065369 100644 --- a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck62.ts +++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck62.ts @@ -6,7 +6,7 @@ export interface StrategicState { lastStrategyApplied?: string; } -export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { +export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { return function*(state) { for (const next of gen(state)) { if (next) { @@ -18,7 +18,7 @@ export function strategy(stratName: string, gen: (a: T } export interface Strategy { - (a: T): IterableIterator; + (a: T): IterableIterator; } export interface State extends StrategicState { @@ -26,7 +26,7 @@ export interface State extends StrategicState { } export const Nothing1: Strategy = strategy("Nothing", function*(state: State) { - return state; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); export const Nothing2: Strategy = strategy("Nothing", function*(state: State) { @@ -35,6 +35,6 @@ export const Nothing2: Strategy = strategy("Nothing", function*(state: St export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { yield ; - return state; + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); \ No newline at end of file diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts index 58411e409b8ab..e50c40265ae0c 100644 --- a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts +++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts @@ -6,7 +6,7 @@ export interface StrategicState { lastStrategyApplied?: string; } -export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { +export function strategy(stratName: string, gen: (a: T) => IterableIterator): (a: T) => IterableIterator { return function*(state) { for (const next of gen(state)) { if (next) { @@ -18,7 +18,7 @@ export function strategy(stratName: string, gen: (a: T } export interface Strategy { - (a: T): IterableIterator; + (a: T): IterableIterator; } export interface State extends StrategicState { @@ -26,18 +26,18 @@ export interface State extends StrategicState { } export const Nothing: Strategy = strategy("Nothing", function* (state: State) { - yield 1; - return state; + yield 1; // number isn't a `State`, so this should error. + return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); export const Nothing1: Strategy = strategy("Nothing", function* (state: State) { }); export const Nothing2: Strategy = strategy("Nothing", function* (state: State) { - return 1; + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { yield state; - return 1; + return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error. }); \ No newline at end of file diff --git a/tests/cases/conformance/generators/generatorReturnTypeFallback.3.ts b/tests/cases/conformance/generators/generatorReturnTypeFallback.3.ts index 388d8bee7ee3b..da84940743db0 100644 --- a/tests/cases/conformance/generators/generatorReturnTypeFallback.3.ts +++ b/tests/cases/conformance/generators/generatorReturnTypeFallback.3.ts @@ -3,8 +3,6 @@ // @noemit: true // @strict: true -// Do not allow generators to fallback to IterableIterator while in strictNullChecks mode if they need a type for the sent value. -// NOTE: In non-strictNullChecks mode, `undefined` (the default sent value) is assignable to everything. function* f() { const x: string = yield 1; } \ No newline at end of file diff --git a/tests/cases/conformance/types/typeAliases/builtinIteratorReturn.ts b/tests/cases/conformance/types/typeAliases/builtinIteratorReturn.ts new file mode 100644 index 0000000000000..cc1852f5af8d3 --- /dev/null +++ b/tests/cases/conformance/types/typeAliases/builtinIteratorReturn.ts @@ -0,0 +1,32 @@ +// @target: esnext +// @noEmit: true +// @strictBuiltinIteratorReturn: * + +declare const array: number[]; +declare const map: Map; +declare const set: Set; + +const i0 = array[Symbol.iterator](); +const i1 = array.values(); +const i2 = array.keys(); +const i3 = array.entries(); +for (const x of array); + +const i4 = map[Symbol.iterator](); +const i5 = map.values(); +const i6 = map.keys(); +const i7 = map.entries(); +for (const x of map); + +const i8 = set[Symbol.iterator](); +const i9 = set.values(); +const i10 = set.keys(); +const i11 = set.entries(); +for (const x of set); + +declare const i12: IterableIterator; +declare const i13: IterableIterator; +declare const i14: IterableIterator; +declare const i15: Iterable; +declare const i16: Iterable; +declare const i17: Iterable; diff --git a/tests/cases/fourslash/codeFixAddMissingProperties22.ts b/tests/cases/fourslash/codeFixAddMissingProperties22.ts index 5bd5ec0705b80..7b54f5ef5933d 100644 --- a/tests/cases/fourslash/codeFixAddMissingProperties22.ts +++ b/tests/cases/fourslash/codeFixAddMissingProperties22.ts @@ -8,7 +8,7 @@ verify.codeFix({ description: ts.Diagnostics.Add_missing_properties.message, newFileContent: `const x: Iterable = { - [Symbol.iterator]: function(): Iterator { + [Symbol.iterator]: function(): Iterator { throw new Error("Function not implemented."); } }`,