Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Consider enclosing declaration when serializing inferred return types (#59170)

Browse Source
This commit is contained in:
Jake Bailey
2024-07-09 14:35:27 -07:00
committed by GitHub
parent 8d84a68776
commit 533acb5ad9
263 changed files with 2694 additions and 2379 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/checker.ts
+3 -5
View File
@@ -8322,11 +8322,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
const typePredicate = getTypePredicateOfSignature(signature);
const type = getReturnTypeOfSignature(signature);
if (context.enclosingDeclaration && (!isErrorType(type) || (context.flags & NodeBuilderFlags.AllowUnresolvedNames)) && signature.declaration && !nodeIsSynthesized(signature.declaration)) {
const annotation = signature.declaration && getNonlocalEffectiveReturnTypeAnnotationNode(signature.declaration);
// Default constructor signatures inherited from base classes return the derived class but have the base class declaration
// To ensure we don't serialize the wrong type we check that that return type of the signature corresponds to the declaration return type signature
if (annotation && getTypeFromTypeNode(context, annotation) === type) {
const result = tryReuseExistingTypeNodeHelper(context, annotation);
const annotation = getNonlocalEffectiveReturnTypeAnnotationNode(signature.declaration);
if (annotation) {
const result = tryReuseExistingTypeNode(context, annotation, type, context.enclosingDeclaration);
if (result) {
return result;
}
tests/baselines/reference/abstractClassUnionInstantiation.types
+8 -8
View File
@@ -75,7 +75,7 @@ new cls3(); // should work
>[ConcreteA, AbstractA, AbstractB].map(cls => new cls()) : any[]
> : ^^^^^
>[ConcreteA, AbstractA, AbstractB].map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[ConcreteA, AbstractA, AbstractB] : (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>ConcreteA : typeof ConcreteA
@@ -85,7 +85,7 @@ new cls3(); // should work
>AbstractB : typeof AbstractB
> : ^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>cls => new cls() : (cls: typeof ConcreteA | typeof AbstractA | typeof AbstractB) => any
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>cls : typeof ConcreteA | typeof AbstractA | typeof AbstractB
@@ -99,7 +99,7 @@ new cls3(); // should work
>[AbstractA, AbstractB, ConcreteA].map(cls => new cls()) : any[]
> : ^^^^^
>[AbstractA, AbstractB, ConcreteA].map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[AbstractA, AbstractB, ConcreteA] : (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>AbstractA : typeof AbstractA
@@ -109,7 +109,7 @@ new cls3(); // should work
>ConcreteA : typeof ConcreteA
> : ^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>cls => new cls() : (cls: typeof ConcreteA | typeof AbstractA | typeof AbstractB) => any
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>cls : typeof ConcreteA | typeof AbstractA | typeof AbstractB
@@ -123,7 +123,7 @@ new cls3(); // should work
>[ConcreteA, ConcreteB].map(cls => new cls()) : ConcreteA[]
> : ^^^^^^^^^^^
>[ConcreteA, ConcreteB].map : <U>(callbackfn: (value: typeof ConcreteA, index: number, array: (typeof ConcreteA)[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[ConcreteA, ConcreteB] : (typeof ConcreteA)[]
> : ^^^^^^^^^^^^^^^^^^^^
>ConcreteA : typeof ConcreteA
@@ -131,7 +131,7 @@ new cls3(); // should work
>ConcreteB : typeof ConcreteB
> : ^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: typeof ConcreteA, index: number, array: (typeof ConcreteA)[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>cls => new cls() : (cls: typeof ConcreteA) => ConcreteA
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>cls : typeof ConcreteA
@@ -145,7 +145,7 @@ new cls3(); // should work
>[AbstractA, AbstractB].map(cls => new cls()) : any[]
> : ^^^^^
>[AbstractA, AbstractB].map : <U>(callbackfn: (value: typeof AbstractA | typeof AbstractB, index: number, array: (typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[AbstractA, AbstractB] : (typeof AbstractA | typeof AbstractB)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>AbstractA : typeof AbstractA
@@ -153,7 +153,7 @@ new cls3(); // should work
>AbstractB : typeof AbstractB
> : ^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: typeof AbstractA | typeof AbstractB, index: number, array: (typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>cls => new cls() : (cls: typeof AbstractA | typeof AbstractB) => any
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>cls : typeof AbstractA | typeof AbstractB
tests/baselines/reference/acceptSymbolAsWeakType.types
+4 -4
View File
@@ -105,11 +105,11 @@ wm.get(s);
>wm.get(s) : boolean | undefined
> : ^^^^^^^^^^^^^^^^^^^
>wm.get : (key: symbol) => boolean | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>wm : WeakMap<symbol, boolean>
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>get : (key: symbol) => boolean | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>s : symbol
> : ^^^^^^
@@ -139,11 +139,11 @@ wr.deref();
>wr.deref() : symbol | undefined
> : ^^^^^^^^^^^^^^^^^^
>wr.deref : () => symbol | undefined
> : ^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>wr : WeakRef<symbol>
> : ^^^^^^^^^^^^^^^
>deref : () => symbol | undefined
> : ^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^
const f = new FinalizationRegistry(() => {});
>f : FinalizationRegistry<unknown>
tests/baselines/reference/accessorsOverrideProperty8.types
+2 -2
View File
@@ -39,9 +39,9 @@ declare function classWithProperties<T extends { [key: string]: Types }, P exten
const Base = classWithProperties({
>Base : { new (): Base & Properties<{ readonly x: "boolean"; y: "string"; }>; prototype: Base & Properties<{ readonly x: "boolean"; y: "string"; }>; }
> : ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>classWithProperties({ get x() { return 'boolean' as const }, y: 'string',}, class Base {}) : { new (): Base & Properties<{ readonly x: "boolean"; y: "string"; }>; prototype: Base & Properties<{ readonly x: "boolean"; y: "string"; }>; }
> : ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>classWithProperties : <T extends { [key: string]: Types; }, P extends object>(properties: T, klass: AnyCtor<P>) => { new (): P & Properties<T>; prototype: P & Properties<T>; }
> : ^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^
>{ get x() { return 'boolean' as const }, y: 'string',} : { readonly x: "boolean"; y: "string"; }
tests/baselines/reference/amdLikeInputDeclarationEmit.types
+3 -3
View File
@@ -57,9 +57,9 @@ define("lib/ExtendedClass", ["deps/BaseClass"],
const ExtendedClass = BaseClass.extends({
>ExtendedClass : new () => { f: () => "something"; } & import("deps/BaseClass")
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>BaseClass.extends({ f: function() { return "something"; } }) : new () => { f: () => "something"; } & import("deps/BaseClass")
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>BaseClass.extends : <A>(a: A) => new () => A & import("deps/BaseClass")
> : ^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^
>BaseClass : typeof import("deps/BaseClass")
@@ -96,7 +96,7 @@ define("lib/ExtendedClass", ["deps/BaseClass"],
>exports : any
> : ^^^
>ExtendedClass : new () => { f: () => "something"; } & import("deps/BaseClass")
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return module.exports;
>module.exports : any
tests/baselines/reference/anyInferenceAnonymousFunctions.types
+4 -4
View File
@@ -86,11 +86,11 @@ paired.map((c1) => c1.count);
>paired.map((c1) => c1.count) : any[]
> : ^^^^^
>paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>paired : any[]
> : ^^^^^
>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>(c1) => c1.count : (c1: any) => any
> : ^ ^^^^^^^^^^^^^
>c1 : any
@@ -104,11 +104,11 @@ paired.map(function (c2) { return c2.count; });
>paired.map(function (c2) { return c2.count; }) : any[]
> : ^^^^^
>paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>paired : any[]
> : ^^^^^
>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>function (c2) { return c2.count; } : (c2: any) => any
> : ^ ^^^^^^^^^^^^^
>c2 : any
tests/baselines/reference/arrayAugment.types
+2 -2
View File
@@ -23,11 +23,11 @@ var y = x.split(4);
>x.split(4) : string[][]
> : ^^^^^^^^^^
>x.split : (parts: number) => string[][]
> : ^ ^^ ^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^
>x : string[]
> : ^^^^^^^^
>split : (parts: number) => string[][]
> : ^ ^^ ^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^
>4 : 4
> : ^
tests/baselines/reference/arrayConcat2.types
+6 -6
View File
@@ -11,11 +11,11 @@ a.concat("hello", 'world');
>a.concat("hello", 'world') : string[]
> : ^^^^^^^^
>a.concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>a : string[]
> : ^^^^^^^^
>concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"hello" : "hello"
> : ^^^^^^^
>'world' : "world"
@@ -25,11 +25,11 @@ a.concat('Hello');
>a.concat('Hello') : string[]
> : ^^^^^^^^
>a.concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>a : string[]
> : ^^^^^^^^
>concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>'Hello' : "Hello"
> : ^^^^^^^
@@ -45,11 +45,11 @@ b.concat('hello');
>b.concat('hello') : string[]
> : ^^^^^^^^
>b.concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>b : string[]
> : ^^^^^^^^
>concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>'hello' : "hello"
> : ^^^^^^^
tests/baselines/reference/arrayConcat3.types
+2 -2
View File
@@ -20,11 +20,11 @@ function doStuff<T extends object, T1 extends T>(a: Array<Fn<T>>, b: Array<Fn<T1
>b.concat(a) : Fn<T1>[]
> : ^^^^^^^^
>b.concat : { (...items: ConcatArray<Fn<T1>>[]): Fn<T1>[]; (...items: (Fn<T1> | ConcatArray<Fn<T1>>)[]): Fn<T1>[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>b : Fn<T1>[]
> : ^^^^^^^^
>concat : { (...items: ConcatArray<Fn<T1>>[]): Fn<T1>[]; (...items: (Fn<T1> | ConcatArray<Fn<T1>>)[]): Fn<T1>[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>a : Fn<T>[]
> : ^^^^^^^
}
tests/baselines/reference/arrayConcatMap.types
+4 -4
View File
@@ -7,15 +7,15 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
>[].concat([{ a: 1 }], [{ a: 2 }]) .map(b => b.a) : any[]
> : ^^^^^
>[].concat([{ a: 1 }], [{ a: 2 }]) .map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[].concat([{ a: 1 }], [{ a: 2 }]) : any[]
> : ^^^^^
>[].concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
>[] : undefined[]
> : ^^^^^^^^^^^
>concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
>[{ a: 1 }] : { a: number; }[]
> : ^^^^^^^^^^^^^^^^
>{ a: 1 } : { a: number; }
@@ -35,7 +35,7 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
.map(b => b.a);
>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>b => b.a : (b: any) => any
> : ^ ^^^^^^^^^^^^^
>b : any
tests/baselines/reference/arrayFilter.types
+2 -2
View File
@@ -35,11 +35,11 @@ foo.filter(x => x.name); //should accepted all possible types not only boolean!
>foo.filter(x => x.name) : { name: string; }[]
> : ^^^^^^^^^^^^^^^^^^^
>foo.filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>foo : { name: string; }[]
> : ^^^^^^^^^^^^^^^^^^^
>filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>x => x.name : (x: { name: string; }) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : { name: string; }
tests/baselines/reference/arrayFind.types
+8 -8
View File
@@ -40,12 +40,12 @@ const foundNumber: number | undefined = arrayOfStringsNumbersAndBooleans.find(is
> : ^^^^^^
>arrayOfStringsNumbersAndBooleans.find(isNumber) : number
> : ^^^^^^
>arrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => unknown, thisArg?: any): (string | number | boolean) | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
>arrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>arrayOfStringsNumbersAndBooleans : (string | number | boolean)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => unknown, thisArg?: any): (string | number | boolean) | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
>find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>isNumber : (x: any) => x is number
> : ^ ^^ ^^^^^
@@ -62,12 +62,12 @@ const readonlyFoundNumber: number | undefined = readonlyArrayOfStringsNumbersAnd
> : ^^^^^^
>readonlyArrayOfStringsNumbersAndBooleans.find(isNumber) : number
> : ^^^^^^
>readonlyArrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => unknown, thisArg?: any): (string | number | boolean) | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
>readonlyArrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>readonlyArrayOfStringsNumbersAndBooleans : readonly (string | number | boolean)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => unknown, thisArg?: any): (string | number | boolean) | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
>find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>isNumber : (x: any) => x is number
> : ^ ^^ ^^^^^
tests/baselines/reference/arrayFlatMap.types
+8 -8
View File
@@ -16,12 +16,12 @@ const readonlyArray: ReadonlyArray<number> = [];
array.flatMap((): ReadonlyArray<number> => []); // ok
>array.flatMap((): ReadonlyArray<number> => []) : number[]
> : ^^^^^^^^
>array.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^ ^^ ^^^^^^^^^^^^^
>array.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^ ^^ ^^^^^^^^^^^^^
>flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
>(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
> : ^^^^^^
>[] : undefined[]
@@ -30,12 +30,12 @@ array.flatMap((): ReadonlyArray<number> => []); // ok
readonlyArray.flatMap((): ReadonlyArray<number> => []); // ok
>readonlyArray.flatMap((): ReadonlyArray<number> => []) : number[]
> : ^^^^^^^^
>readonlyArray.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^ ^^ ^^^^^^^^^^^^^
>readonlyArray.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
>readonlyArray : readonly number[]
> : ^^^^^^^^^^^^^^^^^
>flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^ ^^ ^^^^^^^^^^^^^
>flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
>(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
> : ^^^^^^
>[] : undefined[]
tests/baselines/reference/arrayFlatNoCrashInference.types
+2 -2
View File
@@ -13,11 +13,11 @@ function foo<T>(arr: T[], depth: number) {
>arr.flat(depth) : FlatArray<T, 0 | 1 | -1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20>[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>arr.flat : <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[]
> : ^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^ ^
> : ^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>arr : T[]
> : ^^^
>flat : <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[]
> : ^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^ ^
> : ^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>depth : number
> : ^^^^^^
}
tests/baselines/reference/arrayFlatNoCrashInferenceDeclarations.types
+2 -2
View File
@@ -13,11 +13,11 @@ function foo<T>(arr: T[], depth: number) {
>arr.flat(depth) : FlatArray<T, 0 | 1 | -1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20>[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>arr.flat : <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[]
> : ^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^ ^
> : ^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>arr : T[]
> : ^^^
>flat : <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[]
> : ^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^ ^
> : ^ ^^ ^^^^^^^^^ ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>depth : number
> : ^^^^^^
}
tests/baselines/reference/arrayFrom.types
+4 -4
View File
@@ -86,11 +86,11 @@ const result2: A[] = Array.from(inputA.values());
>inputA.values() : IterableIterator<A>
> : ^^^^^^^^^^^^^^^^^^^
>inputA.values : () => IterableIterator<A>
> : ^^^^^^ ^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>inputA : A[]
> : ^^^
>values : () => IterableIterator<A>
> : ^^^^^^ ^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
const result3: B[] = Array.from(inputA.values()); // expect error
>result3 : B[]
@@ -106,11 +106,11 @@ const result3: B[] = Array.from(inputA.values()); // expect error
>inputA.values() : IterableIterator<A>
> : ^^^^^^^^^^^^^^^^^^^
>inputA.values : () => IterableIterator<A>
> : ^^^^^^ ^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>inputA : A[]
> : ^^^
>values : () => IterableIterator<A>
> : ^^^^^^ ^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
const result4: A[] = Array.from(inputB, ({ b }): A => ({ a: b }));
>result4 : A[]
tests/baselines/reference/arraySlice.types
+2 -2
View File
@@ -9,11 +9,11 @@ arr.splice(1, 1);
>arr.splice(1, 1) : string[] | number[]
> : ^^^^^^^^^^^^^^^^^^^
>arr.splice : { (start: number, deleteCount?: number): string[]; (start: number, deleteCount: number, ...items: string[]): string[]; } | { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>arr : string[] | number[]
> : ^^^^^^^^^^^^^^^^^^^
>splice : { (start: number, deleteCount?: number): string[]; (start: number, deleteCount: number, ...items: string[]): string[]; } | { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>1 : 1
> : ^
>1 : 1
tests/baselines/reference/asyncYieldStarContextualType.types
+4 -4
View File
@@ -66,11 +66,11 @@ async function* f(): AsyncGenerator<"NOT_FOUND_AUTHOR" | "NOT_FOUND_BOOK", BookW
>authorPromise.then(mapper) : Promise<Result<Author, "NOT_FOUND_AUTHOR">>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>authorPromise.then : <TResult1 = Result<Author, "NOT_FOUND_AUTHOR">, TResult2 = never>(onfulfilled?: (value: Result<Author, "NOT_FOUND_AUTHOR">) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>authorPromise : Promise<Result<Author, "NOT_FOUND_AUTHOR">>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>then : <TResult1 = Result<Author, "NOT_FOUND_AUTHOR">, TResult2 = never>(onfulfilled?: (value: Result<Author, "NOT_FOUND_AUTHOR">) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>mapper : <T>(result: Result<T, "NOT_FOUND_AUTHOR">) => Result<T, "NOT_FOUND_AUTHOR">
> : ^ ^^ ^^ ^^^^^
@@ -87,11 +87,11 @@ async function* f(): AsyncGenerator<"NOT_FOUND_AUTHOR" | "NOT_FOUND_BOOK", BookW
>authorPromise.then(mapper) : Promise<Result<Author, "NOT_FOUND_AUTHOR">>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>authorPromise.then : <TResult1 = Result<Author, "NOT_FOUND_AUTHOR">, TResult2 = never>(onfulfilled?: (value: Result<Author, "NOT_FOUND_AUTHOR">) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>authorPromise : Promise<Result<Author, "NOT_FOUND_AUTHOR">>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>then : <TResult1 = Result<Author, "NOT_FOUND_AUTHOR">, TResult2 = never>(onfulfilled?: (value: Result<Author, "NOT_FOUND_AUTHOR">) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>mapper : <T>(result: Result<T, "NOT_FOUND_AUTHOR">) => Result<T, "NOT_FOUND_AUTHOR">
> : ^ ^^ ^^ ^^^^^
tests/baselines/reference/awaitUnionPromise.types
+10 -10
View File
@@ -43,11 +43,11 @@ async function main() {
>x.next1() : Promise<number | AsyncEnumeratorDone>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x.next1 : () => Promise<number | AsyncEnumeratorDone>
> : ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : IAsyncEnumerator<number>
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>next1 : () => Promise<number | AsyncEnumeratorDone>
> : ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
let b = await x.next2();
>b : number | AsyncEnumeratorDone
@@ -56,12 +56,12 @@ async function main() {
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x.next2() : Promise<AsyncEnumeratorDone> | Promise<number>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x.next2 : () => Promise<number> | Promise<AsyncEnumeratorDone>
> : ^^^^^^ ^^^^^^
>x.next2 : () => Promise<AsyncEnumeratorDone> | Promise<number>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : IAsyncEnumerator<number>
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>next2 : () => Promise<number> | Promise<AsyncEnumeratorDone>
> : ^^^^^^ ^^^^^^
>next2 : () => Promise<AsyncEnumeratorDone> | Promise<number>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
let c = await x.next3();
>c : number | {}
@@ -71,11 +71,11 @@ async function main() {
>x.next3() : Promise<number | {}>
> : ^^^^^^^^^^^^^^^^^^^^
>x.next3 : () => Promise<number | {}>
> : ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : IAsyncEnumerator<number>
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>next3 : () => Promise<number | {}>
> : ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
let d = await x.next4();
>d : number | { x: string; }
@@ -85,10 +85,10 @@ async function main() {
>x.next4() : Promise<number | { x: string; }>
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^
>x.next4 : () => Promise<number | { x: string; }>
> : ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
>x : IAsyncEnumerator<number>
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>next4 : () => Promise<number | { x: string; }>
> : ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
}
tests/baselines/reference/awaitedType.types
+2 -2
View File
@@ -802,7 +802,7 @@ async function mainFindMany() {
>Promise.all(promises).then((results) => { const first = results[0] const second = results[1] // error }) : Promise<void>
> : ^^^^^^^^^^^^^
>Promise.all(promises).then : <TResult1 = [number], TResult2 = never>(onfulfilled?: (value: [number]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Promise.all(promises) : Promise<[number]>
> : ^^^^^^^^^^^^^^^^^
>Promise.all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>; <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>; }
@@ -814,7 +814,7 @@ async function mainFindMany() {
>promises : readonly [Promise<number>]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
>then : <TResult1 = [number], TResult2 = never>(onfulfilled?: (value: [number]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>(results) => { const first = results[0] const second = results[1] // error } : (results: [number]) => void
> : ^ ^^^^^^^^^^^^^^^^^^^
>results : [number]
tests/baselines/reference/bestChoiceType.types
+6 -6
View File
@@ -7,7 +7,7 @@
>(''.match(/ /) || []).map(s => s.toLowerCase()) : any[]
> : ^^^^^
>(''.match(/ /) || []).map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>(''.match(/ /) || []) : RegExpMatchArray | []
> : ^^^^^^^^^^^^^^^^^^^^^
>''.match(/ /) || [] : RegExpMatchArray | []
@@ -25,7 +25,7 @@
>[] : []
> : ^^
>map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>s => s.toLowerCase() : (s: any) => any
> : ^ ^^^^^^^^^^^^^
>s : any
@@ -72,11 +72,11 @@ function f1() {
>y.map(s => s.toLowerCase()) : any[]
> : ^^^^^
>y.map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>y : RegExpMatchArray | []
> : ^^^^^^^^^^^^^^^^^^^^^
>map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>s => s.toLowerCase() : (s: any) => any
> : ^ ^^^^^^^^^^^^^
>s : any
@@ -124,11 +124,11 @@ function f2() {
>y.map(s => s.toLowerCase()) : any[]
> : ^^^^^
>y.map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>y : RegExpMatchArray | never[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
>map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>s => s.toLowerCase() : (s: any) => any
> : ^ ^^^^^^^^^^^^^
>s : any
tests/baselines/reference/booleanFilterAnyArray.types
+10 -10
View File
@@ -45,12 +45,12 @@ var xs = anys.filter(Bullean)
> : ^^^^^^^^
>anys.filter(Bullean) : Ari<any>
> : ^^^^^^^^
>anys.filter : { <S extends any>(cb1: (value: any) => value is S): any extends any ? Ari<any> : Ari<S>; (cb2: (value: any) => unknown): Ari<any>; }
> : ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^^ ^^^ ^^^
>anys.filter : { <S extends any>(cb1: (value: any) => value is S): Ari<any>; (cb2: (value: any) => unknown): Ari<any>; }
> : ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^
>anys : Ari<any>
> : ^^^^^^^^
>filter : { <S extends any>(cb1: (value: any) => value is S): any extends any ? Ari<any> : Ari<S>; (cb2: (value: any) => unknown): Ari<any>; }
> : ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^^ ^^^ ^^^
>filter : { <S extends any>(cb1: (value: any) => value is S): Ari<any>; (cb2: (value: any) => unknown): Ari<any>; }
> : ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^
>Bullean : BulleanConstructor
> : ^^^^^^^^^^^^^^^^^^
@@ -68,11 +68,11 @@ var ys = realanys.filter(Boolean)
>realanys.filter(Boolean) : any[]
> : ^^^^^
>realanys.filter : { <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[]; (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[]; }
> : ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^
>realanys : any[]
> : ^^^^^
>filter : { <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[]; (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[]; }
> : ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^
>Boolean : BooleanConstructor
> : ^^^^^^^^^^^^^^^^^^
@@ -100,11 +100,11 @@ var foor = foo.filter(x => x.name)
>foo.filter(x => x.name) : { name: string; }[]
> : ^^^^^^^^^^^^^^^^^^^
>foo.filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>foo : { name: string; }[]
> : ^^^^^^^^^^^^^^^^^^^
>filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>x => x.name : (x: { name: string; }) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : { name: string; }
@@ -126,7 +126,7 @@ var foos = [true, true, false, null].filter((thing): thing is boolean => thing !
>[true, true, false, null].filter((thing): thing is boolean => thing !== null) : boolean[]
> : ^^^^^^^^^
>[true, true, false, null].filter : { <S extends boolean>(predicate: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (predicate: (value: boolean, index: number, array: boolean[]) => unknown, thisArg?: any): boolean[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^
>[true, true, false, null] : boolean[]
> : ^^^^^^^^^
>true : true
@@ -136,7 +136,7 @@ var foos = [true, true, false, null].filter((thing): thing is boolean => thing !
>false : false
> : ^^^^^
>filter : { <S extends boolean>(predicate: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (predicate: (value: boolean, index: number, array: boolean[]) => unknown, thisArg?: any): boolean[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^
>(thing): thing is boolean => thing !== null : (thing: boolean) => thing is boolean
> : ^ ^^^^^^^^^^^^^^
>thing : boolean
tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.types
+8 -8
View File
@@ -55,19 +55,19 @@ class C extends B {
>(new Chain(new A)).then(a => new B).then(b => new C).then(c => new B).then(b => new A) : Chain<C>
> : ^^^^^^^^
>(new Chain(new A)).then(a => new B).then(b => new C).then(c => new B).then : <S extends C>(cb: (x: C) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^
>(new Chain(new A)).then(a => new B).then(b => new C).then(c => new B) : Chain<C>
> : ^^^^^^^^
>(new Chain(new A)).then(a => new B).then(b => new C).then : <S extends C>(cb: (x: C) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^
>(new Chain(new A)).then(a => new B).then(b => new C) : Chain<C>
> : ^^^^^^^^
>(new Chain(new A)).then(a => new B).then : <S extends B>(cb: (x: B) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^
>(new Chain(new A)).then(a => new B) : Chain<B>
> : ^^^^^^^^
>(new Chain(new A)).then : <S extends A>(cb: (x: A) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^
>(new Chain(new A)) : Chain<A>
> : ^^^^^^^^
>new Chain(new A) : Chain<A>
@@ -79,7 +79,7 @@ class C extends B {
>A : typeof A
> : ^^^^^^^^
>then : <S extends A>(cb: (x: A) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^
>a => new B : (a: A) => B
> : ^ ^^^^^^^^^
>a : A
@@ -89,7 +89,7 @@ class C extends B {
>B : typeof B
> : ^^^^^^^^
>then : <S extends B>(cb: (x: B) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^
>b => new C : (b: B) => C
> : ^ ^^^^^^^^^
>b : B
@@ -99,7 +99,7 @@ class C extends B {
>C : typeof C
> : ^^^^^^^^
>then : <S extends C>(cb: (x: C) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^
>c => new B : (c: C) => B
> : ^ ^^^^^^^^^
>c : C
@@ -109,7 +109,7 @@ class C extends B {
>B : typeof B
> : ^^^^^^^^
>then : <S extends C>(cb: (x: C) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^
>b => new A : (b: C) => A
> : ^ ^^^^^^^^^
>b : C
tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.types
+22 -22
View File
@@ -30,7 +30,7 @@ class Chain<T> {
>(new Chain(t)).then(tt => s).then(ss => t) : Chain<S>
> : ^^^^^^^^
>(new Chain(t)).then(tt => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>(new Chain(t)).then(tt => s) : Chain<S>
> : ^^^^^^^^
>(new Chain(t)).then : <S extends T>(cb: (x: T) => S) => Chain<S>
@@ -52,7 +52,7 @@ class Chain<T> {
>s : S
> : ^
>then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>ss => t : (ss: S) => T
> : ^ ^^^^^^^^^
>ss : S
@@ -65,7 +65,7 @@ class Chain<T> {
>(new Chain(s)).then(ss => t) : Chain<S>
> : ^^^^^^^^
>(new Chain(s)).then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>(new Chain(s)) : Chain<S>
> : ^^^^^^^^
>new Chain(s) : Chain<S>
@@ -75,7 +75,7 @@ class Chain<T> {
>s : S
> : ^
>then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>ss => t : (ss: S) => T
> : ^ ^^^^^^^^^
>ss : S
@@ -134,15 +134,15 @@ class Chain<T> {
>(new Chain(s)).then(ss => s).then(ss => s).then(ss => s) : Chain<S>
> : ^^^^^^^^
>(new Chain(s)).then(ss => s).then(ss => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>(new Chain(s)).then(ss => s).then(ss => s) : Chain<S>
> : ^^^^^^^^
>(new Chain(s)).then(ss => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>(new Chain(s)).then(ss => s) : Chain<S>
> : ^^^^^^^^
>(new Chain(s)).then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>(new Chain(s)) : Chain<S>
> : ^^^^^^^^
>new Chain(s) : Chain<S>
@@ -152,7 +152,7 @@ class Chain<T> {
>s : S
> : ^
>then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>ss => s : (ss: S) => S
> : ^ ^^^^^^^^^
>ss : S
@@ -160,7 +160,7 @@ class Chain<T> {
>s : S
> : ^
>then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>ss => s : (ss: S) => S
> : ^ ^^^^^^^^^
>ss : S
@@ -168,7 +168,7 @@ class Chain<T> {
>s : S
> : ^
>then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>ss => s : (ss: S) => S
> : ^ ^^^^^^^^^
>ss : S
@@ -230,7 +230,7 @@ class Chain2<T extends I> {
>(new Chain2(i)).then(ii => t) : Chain2<T>
> : ^^^^^^^^^
>(new Chain2(i)).then : <S extends I>(cb: (x: I) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
>(new Chain2(i)) : Chain2<I>
> : ^^^^^^^^^
>new Chain2(i) : Chain2<I>
@@ -240,7 +240,7 @@ class Chain2<T extends I> {
>i : I
> : ^
>then : <S extends I>(cb: (x: I) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
>ii => t : (ii: I) => T
> : ^ ^^^^^^^^^
>ii : I
@@ -286,7 +286,7 @@ class Chain2<T extends I> {
>(new Chain2(i)).then(ii => t) : Chain2<T>
> : ^^^^^^^^^
>(new Chain2(i)).then : <S extends I>(cb: (x: I) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
>(new Chain2(i)) : Chain2<I>
> : ^^^^^^^^^
>new Chain2(i) : Chain2<I>
@@ -296,7 +296,7 @@ class Chain2<T extends I> {
>i : I
> : ^
>then : <S extends I>(cb: (x: I) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
>ii => t : (ii: I) => T
> : ^ ^^^^^^^^^
>ii : I
@@ -344,19 +344,19 @@ class Chain2<T extends I> {
>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then(ss => s) : Chain2<S>
> : ^^^^^^^^^
>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s) : Chain2<S>
> : ^^^^^^^^^
>(new Chain2(i)).then(ii => s).then(ss => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>(new Chain2(i)).then(ii => s).then(ss => s) : Chain2<S>
> : ^^^^^^^^^
>(new Chain2(i)).then(ii => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>(new Chain2(i)).then(ii => s) : Chain2<S>
> : ^^^^^^^^^
>(new Chain2(i)).then : <S extends I>(cb: (x: I) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
>(new Chain2(i)) : Chain2<I>
> : ^^^^^^^^^
>new Chain2(i) : Chain2<I>
@@ -366,7 +366,7 @@ class Chain2<T extends I> {
>i : I
> : ^
>then : <S extends I>(cb: (x: I) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
>ii => s : (ii: I) => S
> : ^ ^^^^^^^^^
>ii : I
@@ -374,7 +374,7 @@ class Chain2<T extends I> {
>s : S
> : ^
>then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>ss => s : (ss: S) => S
> : ^ ^^^^^^^^^
>ss : S
@@ -382,7 +382,7 @@ class Chain2<T extends I> {
>s : S
> : ^
>then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>ss => s : (ss: S) => S
> : ^ ^^^^^^^^^
>ss : S
@@ -390,7 +390,7 @@ class Chain2<T extends I> {
>s : S
> : ^
>then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>ss => s : (ss: S) => S
> : ^ ^^^^^^^^^
>ss : S
tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.types
+2 -2
View File
@@ -49,11 +49,11 @@ var s2 = s.groupBy(s => s.length);
>s.groupBy(s => s.length) : Sequence<{ key: number; items: string[]; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>s.groupBy : <K>(keySelector: (value: string) => K) => Sequence<{ key: K; items: string[]; }>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>s : Sequence<string>
> : ^^^^^^^^^^^^^^^^
>groupBy : <K>(keySelector: (value: string) => K) => Sequence<{ key: K; items: string[]; }>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>s => s.length : (s: string) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
>s : string
tests/baselines/reference/circularInstantiationExpression.types
+2 -2
View File
@@ -10,8 +10,8 @@ declare function foo<T>(t: T): typeof foo<T>;
> : ^ ^^ ^^ ^^^^^
foo("");
>foo("") : (t: string) => typeof foo<string>
> : ^ ^^^^^^^^^^^^^ ^^^^^^
>foo("") : (t: string) => any
> : ^ ^^^^^^^^^^^^^^^^
>foo : <T>(t: T) => typeof foo<T>
> : ^ ^^ ^^ ^^^^^
>"" : ""
tests/baselines/reference/circularReferenceInReturnType.types
+2 -2
View File
@@ -34,7 +34,7 @@ const res2 = fn2()(() => res2);
>fn2()(() => res2) : (a: unknown) => void
> : ^ ^^^^^^^^^^^^^^
>fn2() : (cb: () => any) => (a: unknown) => void
> : ^ ^^ ^^^^^ ^^^^^^^
> : ^ ^^ ^^^^^^ ^^^^^^^^^^^^^^
>fn2 : <T>() => (cb: () => any) => (a: T) => void
> : ^ ^^^^^^^
>() => res2 : () => (a: unknown) => void
@@ -58,7 +58,7 @@ const res3 = fn3()(() => res3);
>fn3()(() => res3) : (a: unknown) => void
> : ^ ^^^^^^^^^^^^^^
>fn3() : <T2>(cb: (arg: T2) => any) => (a: unknown) => void
> : ^ ^^ ^^^ ^^^^^^^^^ ^^^^^ ^^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^
>fn3 : <T>() => <T2>(cb: (arg: T2) => any) => (a: T) => void
> : ^ ^^^^^^^
>() => res3 : () => (a: unknown) => void
tests/baselines/reference/circularReferenceInReturnType2.types
+1 -1
View File
@@ -109,7 +109,7 @@ const A = object<Something>()({
>object<Something>()({ name: "A", fields: () => ({ a: field({ type: A, resolve() { return { foo: 100, }; }, }), }),}) : ObjectType<Something>
> : ^^^^^^^^^^^^^^^^^^^^^
>object<Something>() : <Fields extends { [Key in keyof Fields]: Field<Something, Key & string>; }>(config: { name: string; fields: Fields | (() => Fields); }) => ObjectType<Something>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>object : <Source>() => <Fields extends { [Key in keyof Fields]: Field<Source, Key & string>; }>(config: { name: string; fields: Fields | (() => Fields); }) => ObjectType<Source>
> : ^ ^^^^^^^
>{ name: "A", fields: () => ({ a: field({ type: A, resolve() { return { foo: 100, }; }, }), }),} : { name: string; fields: () => any; }
tests/baselines/reference/classReferencedInContextualParameterWithinItsOwnBaseExpression.types
+1 -1
View File
@@ -65,7 +65,7 @@ export class A extends Class<A>("A")(
>Class<A>("A")( { a: string }, { pretty: (a) => JSON.stringify(a), },) : OutputFrom<{ a: () => Type<string>; }>
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^
>Class<A>("A") : <Fields>(fields: Fields, annotations?: Schema<A> | undefined) => Class<OutputFrom<Fields>>
> : ^ ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Class : <Self>(identifier: string) => <Fields>(fields: Fields, annotations?: Schema<Self>) => Class<OutputFrom<Fields>>
> : ^ ^^ ^^ ^^^^^
>"A" : "A"
tests/baselines/reference/classStaticBlock23(target=es2022).types
+2 -2
View File
@@ -7,7 +7,7 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
>[1, 2, 3].map(n => Promise.resolve(n)) : Promise<number>[]
> : ^^^^^^^^^^^^^^^^^
>[1, 2, 3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[1, 2, 3] : number[]
> : ^^^^^^^^
>1 : 1
@@ -17,7 +17,7 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
>3 : 3
> : ^
>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>n => Promise.resolve(n) : (n: number) => Promise<number>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>n : number
tests/baselines/reference/classStaticBlock23(target=esnext).types
+2 -2
View File
@@ -7,7 +7,7 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
>[1, 2, 3].map(n => Promise.resolve(n)) : Promise<number>[]
> : ^^^^^^^^^^^^^^^^^
>[1, 2, 3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[1, 2, 3] : number[]
> : ^^^^^^^^
>1 : 1
@@ -17,7 +17,7 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
>3 : 3
> : ^
>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>n => Promise.resolve(n) : (n: number) => Promise<number>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>n : number
tests/baselines/reference/coAndContraVariantInferences3.types
+8 -8
View File
@@ -292,16 +292,16 @@ declare const DISALLOW_DECORATORS: DeprecationOptions;
buildOverload("updateImportDeclaration")
>buildOverload("updateImportDeclaration") .overload({ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, }) .bind({ 0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) => (other === undefined) && (modifiers === undefined || every(modifiers, isModifier)) && (importClause === undefined || !isArray(importClause)) && (moduleSpecifier === undefined || isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), 1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) => (decorators === undefined || every(decorators, isDecorator)) && (modifiers === undefined || isArray(modifiers)) && (importClause === undefined || isImportClause(importClause)) && (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), }) .deprecate({ 1: DISALLOW_DECORATORS }) .finish() : ((node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration) & ((node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration)
> : ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^
>buildOverload("updateImportDeclaration") .overload({ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, }) .bind({ 0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) => (other === undefined) && (modifiers === undefined || every(modifiers, isModifier)) && (importClause === undefined || !isArray(importClause)) && (moduleSpecifier === undefined || isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), 1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) => (decorators === undefined || every(decorators, isDecorator)) && (modifiers === undefined || isArray(modifiers)) && (importClause === undefined || isImportClause(importClause)) && (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), }) .deprecate({ 1: DISALLOW_DECORATORS }) .finish : () => OverloadFunction<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
> : ^^^^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>buildOverload("updateImportDeclaration") .overload({ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, }) .bind({ 0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) => (other === undefined) && (modifiers === undefined || every(modifiers, isModifier)) && (importClause === undefined || !isArray(importClause)) && (moduleSpecifier === undefined || isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), 1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) => (decorators === undefined || every(decorators, isDecorator)) && (modifiers === undefined || isArray(modifiers)) && (importClause === undefined || isImportClause(importClause)) && (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), }) .deprecate({ 1: DISALLOW_DECORATORS }) .finish : () => ((node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration) & ((node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration)
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^
>buildOverload("updateImportDeclaration") .overload({ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, }) .bind({ 0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) => (other === undefined) && (modifiers === undefined || every(modifiers, isModifier)) && (importClause === undefined || !isArray(importClause)) && (moduleSpecifier === undefined || isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), 1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) => (decorators === undefined || every(decorators, isDecorator)) && (modifiers === undefined || isArray(modifiers)) && (importClause === undefined || isImportClause(importClause)) && (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), }) .deprecate({ 1: DISALLOW_DECORATORS }) : FinishableOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^
>buildOverload("updateImportDeclaration") .overload({ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, }) .bind({ 0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) => (other === undefined) && (modifiers === undefined || every(modifiers, isModifier)) && (importClause === undefined || !isArray(importClause)) && (moduleSpecifier === undefined || isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), 1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) => (decorators === undefined || every(decorators, isDecorator)) && (modifiers === undefined || isArray(modifiers)) && (importClause === undefined || isImportClause(importClause)) && (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), }) .deprecate : (deprecations: OverloadDeprecations<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>) => FinishableOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^
>buildOverload("updateImportDeclaration") .overload({ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, }) .bind({ 0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) => (other === undefined) && (modifiers === undefined || every(modifiers, isModifier)) && (importClause === undefined || !isArray(importClause)) && (moduleSpecifier === undefined || isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), 1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) => (decorators === undefined || every(decorators, isDecorator)) && (modifiers === undefined || isArray(modifiers)) && (importClause === undefined || isImportClause(importClause)) && (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), }) : BoundOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^
>buildOverload("updateImportDeclaration") .overload({ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, }) .bind : (binder: OverloadBinders<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>) => BoundOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^
>buildOverload("updateImportDeclaration") .overload({ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration { return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); }, }) : BindableOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^
>buildOverload("updateImportDeclaration") .overload : <T extends OverloadDefinitions>(overloads: T) => BindableOverloadBuilder<T>
@@ -387,7 +387,7 @@ buildOverload("updateImportDeclaration")
})
.bind({
>bind : (binder: OverloadBinders<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>) => BoundOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^
>{ 0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) => (other === undefined) && (modifiers === undefined || every(modifiers, isModifier)) && (importClause === undefined || !isArray(importClause)) && (moduleSpecifier === undefined || isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), 1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) => (decorators === undefined || every(decorators, isDecorator)) && (modifiers === undefined || isArray(modifiers)) && (importClause === undefined || isImportClause(importClause)) && (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) && (assertClause === undefined || isAssertClause(assertClause)), } : { 0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]: [node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined] | [node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined]) => boolean; 1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]: [node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined] | [node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined]) => boolean; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -624,7 +624,7 @@ buildOverload("updateImportDeclaration")
})
.deprecate({
>deprecate : (deprecations: OverloadDeprecations<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>) => FinishableOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^
>{ 1: DISALLOW_DECORATORS } : { 1: DeprecationOptions; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -636,8 +636,8 @@ buildOverload("updateImportDeclaration")
})
.finish();
>finish : () => OverloadFunction<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
> : ^^^^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>finish : () => ((node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration) & ((node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration)
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^
declare const modifiers: readonly Modifier[] | readonly Decorator[];
tests/baselines/reference/collectionPatternNoError.types
+4 -4
View File
@@ -73,11 +73,11 @@ class DataProvider<T extends Message, U extends MessageList<T>> {
>messageList.methodOnMessageList() : T[]
> : ^^^
>messageList.methodOnMessageList : () => T[]
> : ^^^^^^^
> : ^^^^^^^^^
>messageList : U
> : ^
>methodOnMessageList : () => T[]
> : ^^^^^^^
> : ^^^^^^^^^
}
}
@@ -102,7 +102,7 @@ function f<
>fetchMsg(messageList).methodOnMessageList() : T[]
> : ^^^
>fetchMsg(messageList).methodOnMessageList : () => T[]
> : ^^^^^^^
> : ^^^^^^^^^
>fetchMsg(messageList) : U["TType"]
> : ^^^^^^^^^^
>fetchMsg : <V extends Message>(protoCtor: MsgConstructor<V>) => V
@@ -110,6 +110,6 @@ function f<
>messageList : MsgConstructor<U["TType"]>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
>methodOnMessageList : () => T[]
> : ^^^^^^^
> : ^^^^^^^^^
}
tests/baselines/reference/commaOperatorInConditionalExpression.types
+2 -2
View File
@@ -11,7 +11,7 @@ function f (m: string) {
>[1, 2, 3].map(i => { return true? { [m]: i } : { [m]: i + 1 } }) : { [x: string]: number; }[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
>[1, 2, 3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[1, 2, 3] : number[]
> : ^^^^^^^^
>1 : 1
@@ -21,7 +21,7 @@ function f (m: string) {
>3 : 3
> : ^
>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>i => { return true? { [m]: i } : { [m]: i + 1 } } : (i: number) => { [x: string]: number; }
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>i : number
tests/baselines/reference/commentInMethodCall.types
+2 -2
View File
@@ -10,11 +10,11 @@ s.map(// do something
>s.map(// do something function () { }) : void[]
> : ^^^^^^
>s.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>s : string[]
> : ^^^^^^^^
>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
function () { });
>function () { } : () => void
tests/baselines/reference/concatError.types
+4 -4
View File
@@ -23,11 +23,11 @@ fa = fa.concat([0]);
>fa.concat([0]) : number[]
> : ^^^^^^^^
>fa.concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fa : number[]
> : ^^^^^^^^
>concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>[0] : number[]
> : ^^^^^^^^
>0 : 0
@@ -41,11 +41,11 @@ fa = fa.concat(0);
>fa.concat(0) : number[]
> : ^^^^^^^^
>fa.concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fa : number[]
> : ^^^^^^^^
>concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
tests/baselines/reference/concatTuples.types
+2 -2
View File
@@ -21,11 +21,11 @@ ijs = ijs.concat([[3, 4], [5, 6]]);
>ijs.concat([[3, 4], [5, 6]]) : [number, number][]
> : ^^^^^^^^^^^^^^^^^^
>ijs.concat : { (...items: ConcatArray<[number, number]>[]): [number, number][]; (...items: ([number, number] | ConcatArray<[number, number]>)[]): [number, number][]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>ijs : [number, number][]
> : ^^^^^^^^^^^^^^^^^^
>concat : { (...items: ConcatArray<[number, number]>[]): [number, number][]; (...items: ([number, number] | ConcatArray<[number, number]>)[]): [number, number][]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>[[3, 4], [5, 6]] : [number, number][]
> : ^^^^^^^^^^^^^^^^^^
>[3, 4] : [number, number]
tests/baselines/reference/contextualExpressionTypecheckingDoesntBlowStack.types
+2 -2
View File
@@ -100,7 +100,7 @@ export default class Operation {
>(result || []).concat(innerResult) : IValidationError[]
> : ^^^^^^^^^^^^^^^^^^
>(result || []).concat : { (...items: ConcatArray<IValidationError>[]): IValidationError[]; (...items: (IValidationError | ConcatArray<IValidationError>)[]): IValidationError[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>(result || []) : IValidationError[]
> : ^^^^^^^^^^^^^^^^^^
>result || [] : IValidationError[]
@@ -110,7 +110,7 @@ export default class Operation {
>[] : never[]
> : ^^^^^^^
>concat : { (...items: ConcatArray<IValidationError>[]): IValidationError[]; (...items: (IValidationError | ConcatArray<IValidationError>)[]): IValidationError[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>innerResult : any
}
}
tests/baselines/reference/contextualOverloadListFromArrayUnion.types
+4 -4
View File
@@ -11,11 +11,11 @@ export const yThen = y.map(item => item.length);
>y.map(item => item.length) : number[]
> : ^^^^^^^^
>y.map : (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[])
> : ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^
> : ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>y : never[] | string[]
> : ^^^^^^^^^^^^^^^^^^
>map : (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[])
> : ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^
> : ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>item => item.length : (item: string) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
>item : string
@@ -38,11 +38,11 @@ export const yThen = y.map(item => item.length);
>y.map(item => item.length) : number[]
> : ^^^^^^^^
>y.map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: number[], index: number, array: number[][]) => U, thisArg?: any) => U[])
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^^^^^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>y : string[] | number[][]
> : ^^^^^^^^^^^^^^^^^^^^^
>map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: number[], index: number, array: number[][]) => U, thisArg?: any) => U[])
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^^^^^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^ ^
> : ^^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>item => item.length : (item: string | number[]) => number
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>item : string | number[]
tests/baselines/reference/contextualSignatureInstantiation1.types
+4 -4
View File
@@ -29,9 +29,9 @@ var e = <K>(x: string, y?: K) => x.length;
var r99 = map(e); // should be {}[] for S since a generic lambda is not inferentially typed
>r99 : <K>(a: string[]) => number[]
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>map(e) : <K>(a: string[]) => number[]
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>map : <S, T>(f: (x: S) => T) => (a: S[]) => T[]
> : ^ ^^ ^^ ^^ ^^^^^
>e : <K>(x: string, y?: K) => number
@@ -67,9 +67,9 @@ var e2 = <K>(x: string, y?: K) => x.length;
var r100 = map2(e2); // type arg inference should fail for S since a generic lambda is not inferentially typed. Falls back to { length: number }
>r100 : <K>(a: string[]) => number[]
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>map2(e2) : <K>(a: string[]) => number[]
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>map2 : <S extends { length: number; }, T>(f: (x: S) => T) => (a: S[]) => T[]
> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^
>e2 : <K>(x: string, y?: K) => number
tests/baselines/reference/contextualSignatureInstantiation2.types
+1 -1
View File
@@ -62,7 +62,7 @@ var r23 = dot(id)(id);
>dot(id)(id) : <T>(_: T) => unknown
> : ^ ^^ ^^^^^^^^^^^^^^^
>dot(id) : <U>(g: (_: U) => unknown) => (_: U) => unknown
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
>dot : <T, S>(f: (_: T) => S) => <U>(g: (_: U) => T) => (_: U) => S
> : ^ ^^ ^^ ^^ ^^^^^
>id : <T>(x: T) => T
tests/baselines/reference/contextualSignatureInstantiation3.types
+6 -6
View File
@@ -15,11 +15,11 @@ function map<T, U>(items: T[], f: (x: T) => U): U[]{
>items.map(f) : U[]
> : ^^^
>items.map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^
>items : T[]
> : ^^^
>map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^
>f : (x: T) => U
> : ^ ^^ ^^^^^
}
@@ -71,11 +71,11 @@ var v1 = xs.map(identity); // Error if not number[]
>xs.map(identity) : number[]
> : ^^^^^^^^
>xs.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>xs : number[]
> : ^^^^^^^^
>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>identity : <T>(x: T) => T
> : ^ ^^ ^^ ^^^^^^
@@ -101,11 +101,11 @@ var v2 = xs.map(singleton); // Error if not number[][]
>xs.map(singleton) : number[][]
> : ^^^^^^^^^^
>xs.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>xs : number[]
> : ^^^^^^^^
>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>singleton : <T>(x: T) => T[]
> : ^ ^^ ^^ ^^^^^^^^
tests/baselines/reference/contextuallyTypeAsyncFunctionReturnType.types
+4 -4
View File
@@ -301,17 +301,17 @@ async function copyExtensions(
>fromExtensions .filter((e) => !e.isApplicationScoped) .map(async (e) => [e, await scanMetadata(e)]) : Promise<[ILocalExtension, Metadata]>[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fromExtensions .filter((e) => !e.isApplicationScoped) .map : <U>(callbackfn: (value: ILocalExtension, index: number, array: ILocalExtension[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>fromExtensions .filter((e) => !e.isApplicationScoped) : ILocalExtension[]
> : ^^^^^^^^^^^^^^^^^
>fromExtensions .filter : { <S extends ILocalExtension>(predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => value is S, thisArg?: any): S[]; (predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => unknown, thisArg?: any): ILocalExtension[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
>fromExtensions : ILocalExtension[]
> : ^^^^^^^^^^^^^^^^^
.filter((e) => !e.isApplicationScoped)
>filter : { <S extends ILocalExtension>(predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => value is S, thisArg?: any): S[]; (predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => unknown, thisArg?: any): ILocalExtension[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
>(e) => !e.isApplicationScoped : (e: ILocalExtension) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>e : ILocalExtension
@@ -327,7 +327,7 @@ async function copyExtensions(
.map(async (e) => [e, await scanMetadata(e)])
>map : <U>(callbackfn: (value: ILocalExtension, index: number, array: ILocalExtension[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>async (e) => [e, await scanMetadata(e)] : (e: ILocalExtension) => Promise<[ILocalExtension, Metadata]>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>e : ILocalExtension
tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types
+4 -4
View File
@@ -120,13 +120,13 @@ const cb1: LoadCallback = async () => load().then(m => m);
>load().then(m => m) : Promise<boolean>
> : ^^^^^^^^^^^^^^^^
>load().then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>load() : Promise<boolean>
> : ^^^^^^^^^^^^^^^^
>load : () => Promise<boolean>
> : ^^^^^^
>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>m => m : (m: boolean) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^
>m : boolean
@@ -152,13 +152,13 @@ const cb3: LoadCallback = () => load().then(m => m);
>load().then(m => m) : Promise<boolean>
> : ^^^^^^^^^^^^^^^^
>load().then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>load() : Promise<boolean>
> : ^^^^^^^^^^^^^^^^
>load : () => Promise<boolean>
> : ^^^^^^
>then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>m => m : (m: boolean) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^
>m : boolean
tests/baselines/reference/contextuallyTypedIife.types
+2 -2
View File
@@ -282,11 +282,11 @@
>rest.map(n => n > 0) : boolean[]
> : ^^^^^^^^^
>rest.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>rest : [number, number]
> : ^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>n => n > 0 : (n: number) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^
>n : number
tests/baselines/reference/contextuallyTypedIifeStrict.types
+2 -2
View File
@@ -290,11 +290,11 @@
>rest.map(n => n > 0) : boolean[]
> : ^^^^^^^^^
>rest.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>rest : [number, number]
> : ^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>n => n > 0 : (n: number) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^
>n : number
tests/baselines/reference/contravariantInferenceAndTypeGuard.types
+2 -2
View File
@@ -89,11 +89,11 @@ const filter1 = list2.filter(function(item, node, list): item is Test {
>list2.filter(function(item, node, list): item is Test { this.b; // $ExpectType string item; // $ExpectType Test | null node; // $ExpectType ListItem<Test | null> list; // $ExpectType List<Test | null> return !!item;}, {b: 'c'}) : List<Test>
> : ^^^^^^^^^^
>list2.filter : { <TContext, TResult extends Test | null>(fn: FilterFn<Test | null, TResult, TContext>, context: TContext): List<TResult>; <TResult extends Test | null>(fn: FilterFn<Test | null, TResult, List<Test | null>>): List<TResult>; <TContext>(fn: IteratorFn<Test | null, boolean, TContext>, context: TContext): List<Test | null>; (fn: IteratorFn<Test | null, boolean, List<Test | null>>): List<Test | null>; }
> : ^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>list2 : List<Test | null>
> : ^^^^^^^^^^^^^^^^^
>filter : { <TContext, TResult extends Test | null>(fn: FilterFn<Test | null, TResult, TContext>, context: TContext): List<TResult>; <TResult extends Test | null>(fn: FilterFn<Test | null, TResult, List<Test | null>>): List<TResult>; <TContext>(fn: IteratorFn<Test | null, boolean, TContext>, context: TContext): List<Test | null>; (fn: IteratorFn<Test | null, boolean, List<Test | null>>): List<Test | null>; }
> : ^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>function(item, node, list): item is Test { this.b; // $ExpectType string item; // $ExpectType Test | null node; // $ExpectType ListItem<Test | null> list; // $ExpectType List<Test | null> return !!item;} : (this: { b: string; }, item: Test | null, node: ListItem<Test | null>, list: List<Test | null>) => item is Test
> : ^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>item : Test | null
tests/baselines/reference/controlFlowDestructuringParameters.types
+2 -2
View File
@@ -8,7 +8,7 @@
>[{ x: 1 }].map( ({ x }) => x) : number[]
> : ^^^^^^^^
>[{ x: 1 }].map : <U>(callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[{ x: 1 }] : { x: number; }[]
> : ^^^^^^^^^^^^^^^^
>{ x: 1 } : { x: number; }
@@ -18,7 +18,7 @@
>1 : 1
> : ^
>map : <U>(callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
({ x }) => x
>({ x }) => x : ({ x }: { x: number; }) => number
tests/baselines/reference/controlFlowOuterVariable.types
+2 -2
View File
@@ -53,11 +53,11 @@ const helper = function<T>(t: T[]) {
>t.slice(1) : T[]
> : ^^^
>t.slice : (start?: number, end?: number) => T[]
> : ^ ^^^ ^^ ^^^ ^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^
>t : T[]
> : ^^^
>slice : (start?: number, end?: number) => T[]
> : ^ ^^^ ^^ ^^^ ^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^
>1 : 1
> : ^
}
tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types
+2 -2
View File
@@ -47,13 +47,13 @@ export let lazyCard = () => import('./Card').then(a => a.default);
>import('./Card').then(a => a.default) : Promise<(suit: import("Types").Suit, rank: import("Types").Rank) => { suit: import("Types").Suit; rank: import("Types").Rank; }>
> : ^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>import('./Card').then : <TResult1 = typeof import("Card"), TResult2 = never>(onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>import('./Card') : Promise<typeof import("Card")>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>'./Card' : "./Card"
> : ^^^^^^^^
>then : <TResult1 = typeof import("Card"), TResult2 = never>(onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>a => a.default : (a: typeof import("Card")) => (suit: import("Types").Suit, rank: import("Types").Rank) => { suit: import("Types").Suit; rank: import("Types").Rank; }
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>a : typeof import("Card")
tests/baselines/reference/declarationEmitHigherOrderRetainedGenerics.types
+5 -5
View File
@@ -337,19 +337,19 @@ export const zipWith = <F extends TypeLambda>(F: SemiApplicative<F>): {
>F.map(F.product(self, that), ([a, b]) => f(a, b)) : Kind<F, R1 & R2, O1 | O2, E1 | E2, C>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>F.map : { <A_1, B_1>(f: (a: A_1) => B_1): <R, O, E>(self: Kind<F, R, O, E, A_1>) => Kind<F, R, O, E, B_1>; <R, O, E, A_1, B_1>(self: Kind<F, R, O, E, A_1>, f: (a: A_1) => B_1): Kind<F, R, O, E, B_1>; }
> : ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^ ^^^ ^ ^^^ ^^^ ^^ ^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^ ^ ^ ^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>F : SemiApplicative<F>
> : ^^^^^^^^^^^^^^^^^^
>map : { <A_1, B_1>(f: (a: A_1) => B_1): <R, O, E>(self: Kind<F, R, O, E, A_1>) => Kind<F, R, O, E, B_1>; <R, O, E, A_1, B_1>(self: Kind<F, R, O, E, A_1>, f: (a: A_1) => B_1): Kind<F, R, O, E, B_1>; }
> : ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^ ^^^ ^ ^^^ ^^^ ^^ ^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^ ^ ^ ^ ^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>F.product(self, that) : Kind<F, R1 & R2, O1 | O2, E1 | E2, [A, B]>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>F.product : <R1_1, O1_1, E1_1, A_1, R2_1, O2_1, E2_1, B_1>(self: Kind<F, R1_1, O1_1, E1_1, A_1>, that: Kind<F, R2_1, O2_1, E2_1, B_1>) => Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, [A_1, B_1]>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>F : SemiApplicative<F>
> : ^^^^^^^^^^^^^^^^^^
>product : <R1_1, O1_1, E1_1, A_1, R2_1, O2_1, E2_1, B_1>(self: Kind<F, R1_1, O1_1, E1_1, A_1>, that: Kind<F, R2_1, O2_1, E2_1, B_1>) => Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, [A_1, B_1]>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>self : Kind<F, R1, O1, E1, A>
> : ^^^^^^^^^^^^^^^^^^^^^^
>that : Kind<F, R2, O2, E2, B>
@@ -422,7 +422,7 @@ export const zipRight = <F extends TypeLambda>(F: SemiApplicative<F>): {
>zipWith(F)(self, that, SK) : Kind<F, R1 & R2, O1 | O2, E1 | E2, B>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>zipWith(F) : { <R2_1, O2_1, E2_1, B_1, A, C>(that: Kind<F, R2_1, O2_1, E2_1, B_1>, f: (a: A, b: B_1) => C): <R1_1, O1_1, E1_1>(self: Kind<F, R1_1, O1_1, E1_1, A>) => Kind<F, R1_1 & R2_1, O2_1 | O1_1, E2_1 | E1_1, C>; <R1_1, O1_1, E1_1, A, R2_1, O2_1, E2_1, B_1, C>(self: Kind<F, R1_1, O1_1, E1_1, A>, that: Kind<F, R2_1, O2_1, E2_1, B_1>, f: (a: A, b: B_1) => C): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, C>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^ ^ ^ ^ ^^^^ ^^^^ ^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^ ^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>zipWith : <F extends TypeLambda>(F: SemiApplicative<F>) => { <R2_1, O2_1, E2_1, B_1, A, C>(that: Kind<F, R2_1, O2_1, E2_1, B_1>, f: (a: A, b: B_1) => C): <R1_1, O1_1, E1_1>(self: Kind<F, R1_1, O1_1, E1_1, A>) => Kind<F, R1_1 & R2_1, O2_1 | O1_1, E2_1 | E1_1, C>; <R1_1, O1_2, E1_2, A_1, R2_1, O2_2, E2_2, B_2, C_1>(self: Kind<F, R1_1, O1_2, E1_2, A_1>, that: Kind<F, R2_1, O2_2, E2_2, B_2>, f: (a: A_1, b: B_2) => C_1): Kind<F, R1_1 & R2_1, O1_2 | O2_2, E1_2 | E2_2, C_1>; }
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^
>F : SemiApplicative<F>
tests/baselines/reference/declarationEmitPromise.types
+4 -4
View File
@@ -41,7 +41,7 @@ export async function runSampleWorks<A, B, C, D, E>(
>[a, b, c, d, e].filter(el => !!el) : bluebird<A>[]
> : ^^^^^^^^^^^^^
>[a, b, c, d, e].filter : { <S extends bluebird<A>>(predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => unknown, thisArg?: any): bluebird<A>[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^
>[a, b, c, d, e] : bluebird<A>[]
> : ^^^^^^^^^^^^^
>a : bluebird<A>
@@ -55,7 +55,7 @@ export async function runSampleWorks<A, B, C, D, E>(
>e : bluebird<E>
> : ^^^^^^^^^^^
>filter : { <S extends bluebird<A>>(predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => unknown, thisArg?: any): bluebird<A>[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^
>el => !!el : (el: bluebird<A>) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>el : bluebird<A>
@@ -141,7 +141,7 @@ export async function runSampleBreaks<A, B, C, D, E>(
>[a, b, c, d, e].filter(el => !!el) : bluebird<A>[]
> : ^^^^^^^^^^^^^
>[a, b, c, d, e].filter : { <S extends bluebird<A>>(predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => unknown, thisArg?: any): bluebird<A>[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^
>[a, b, c, d, e] : bluebird<A>[]
> : ^^^^^^^^^^^^^
>a : bluebird<A>
@@ -155,7 +155,7 @@ export async function runSampleBreaks<A, B, C, D, E>(
>e : bluebird<E>
> : ^^^^^^^^^^^
>filter : { <S extends bluebird<A>>(predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => unknown, thisArg?: any): bluebird<A>[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^
>el => !!el : (el: bluebird<A>) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>el : bluebird<A>
tests/baselines/reference/declarationEmitQualifiedAliasTypeArgument.types
+4 -4
View File
@@ -56,17 +56,17 @@ import { create } from "./bbb";
export const fun = create<T>();
>fun : () => import("bbb").INode<T>
> : ^^^^^^ ^^^^^ ^^^^^ ^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>create<T>() : () => import("bbb").INode<T>
> : ^^^^^^ ^^^^^ ^^^^^ ^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>create : <T>() => () => import("bbb").INode<T>
> : ^ ^^^^^^^ ^^^^^ ^^^^^
export const fun2 = create<Q>();
>fun2 : () => import("bbb").INode<Q>
> : ^^^^^^ ^^^^^ ^^^^^ ^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>create<Q>() : () => import("bbb").INode<Q>
> : ^^^^^^ ^^^^^ ^^^^^ ^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>create : <T>() => () => import("bbb").INode<T>
> : ^ ^^^^^^^ ^^^^^ ^^^^^
tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types
+13 -13
View File
@@ -373,12 +373,12 @@ export { UseQueryReturnType, useQuery } from './useQuery-CPqkvEsh.js';
>UseQueryReturnType : any
> : ^^^
>useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").UseQueryReturnType<TData, TError>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
=== src/index.mts ===
import { useQuery } from '@tanstack/vue-query'
>useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").UseQueryReturnType<TData, TError>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
const baseUrl = 'https://api.publicapis.org/'
>baseUrl : "https://api.publicapis.org/"
@@ -431,16 +431,16 @@ const testApi = {
return fetch(baseUrl + 'entries')
>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch((err) => console.log(err)) : Promise<any>
> : ^^^^^^^^^^^^
>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any | TResult>
> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^
>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>
> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) : Promise<any>
> : ^^^^^^^^^^^^
>fetch(baseUrl + 'entries') .then((res) => res.json()) .then : <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fetch(baseUrl + 'entries') .then((res) => res.json()) : Promise<any>
> : ^^^^^^^^^^^^
>fetch(baseUrl + 'entries') .then : <TResult1 = Response, TResult2 = never>(onfulfilled?: ((value: Response) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fetch(baseUrl + 'entries') : Promise<Response>
> : ^^^^^^^^^^^^^^^^^
>fetch : (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
@@ -454,7 +454,7 @@ const testApi = {
.then((res) => res.json())
>then : <TResult1 = Response, TResult2 = never>(onfulfilled?: ((value: Response) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>(res) => res.json() : (res: Response) => Promise<any>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>res : Response
@@ -470,7 +470,7 @@ const testApi = {
.then((data) => data.entries)
>then : <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>(data) => data.entries : (data: any) => any
> : ^ ^^^^^^^^^^^^^
>data : any
@@ -481,8 +481,8 @@ const testApi = {
> : ^^^
.catch((err) => console.log(err))
>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any | TResult>
> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^
>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>
> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>(err) => console.log(err) : (err: any) => void
> : ^ ^^^^^^^^^^^^^^
>err : any
@@ -545,7 +545,7 @@ export const useEntries = () => {
>useQuery({ queryKey: entryKeys.list(), queryFn: testApi.getEntries, select: (data) => data.slice(0, 10) }) : import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").UseQueryReturnType<IEntry[], Error>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").UseQueryReturnType<TData, TError>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
>{ queryKey: entryKeys.list(), queryFn: testApi.getEntries, select: (data) => data.slice(0, 10) } : { queryKey: readonly ["entries", "list"]; queryFn: () => Promise<IEntry[]>; select: (data: IEntry[]) => IEntry[]; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -581,11 +581,11 @@ export const useEntries = () => {
>data.slice(0, 10) : IEntry[]
> : ^^^^^^^^
>data.slice : (start?: number, end?: number) => IEntry[]
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^
>data : IEntry[]
> : ^^^^^^^^
>slice : (start?: number, end?: number) => IEntry[]
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^
>0 : 0
> : ^
>10 : 10
tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types
+14 -14
View File
@@ -379,14 +379,14 @@ export { b as UseQueryReturnType, u as useQuery } from './useQuery-CPqkvEsh.js';
>UseQueryReturnType : any
> : ^^^
>u : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").b<TData, TError>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
>useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").b<TData, TError>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
=== src/index.mts ===
import { useQuery } from '@tanstack/vue-query'
>useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").b<TData, TError>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
const baseUrl = 'https://api.publicapis.org/'
>baseUrl : "https://api.publicapis.org/"
@@ -439,16 +439,16 @@ const testApi = {
return fetch(baseUrl + 'entries')
>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch((err) => console.log(err)) : Promise<any>
> : ^^^^^^^^^^^^
>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any | TResult>
> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^
>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>
> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) : Promise<any>
> : ^^^^^^^^^^^^
>fetch(baseUrl + 'entries') .then((res) => res.json()) .then : <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fetch(baseUrl + 'entries') .then((res) => res.json()) : Promise<any>
> : ^^^^^^^^^^^^
>fetch(baseUrl + 'entries') .then : <TResult1 = Response, TResult2 = never>(onfulfilled?: ((value: Response) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fetch(baseUrl + 'entries') : Promise<Response>
> : ^^^^^^^^^^^^^^^^^
>fetch : (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
@@ -462,7 +462,7 @@ const testApi = {
.then((res) => res.json())
>then : <TResult1 = Response, TResult2 = never>(onfulfilled?: ((value: Response) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>(res) => res.json() : (res: Response) => Promise<any>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>res : Response
@@ -478,7 +478,7 @@ const testApi = {
.then((data) => data.entries)
>then : <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>(data) => data.entries : (data: any) => any
> : ^ ^^^^^^^^^^^^^
>data : any
@@ -489,8 +489,8 @@ const testApi = {
> : ^^^
.catch((err) => console.log(err))
>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any | TResult>
> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^
>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>
> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>(err) => console.log(err) : (err: any) => void
> : ^ ^^^^^^^^^^^^^^
>err : any
@@ -553,7 +553,7 @@ export const useEntries = () => {
>useQuery({ queryKey: entryKeys.list(), queryFn: testApi.getEntries, select: (data) => data.slice(0, 10) }) : import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").b<IEntry[], Error>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").b<TData, TError>
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
>{ queryKey: entryKeys.list(), queryFn: testApi.getEntries, select: (data) => data.slice(0, 10) } : { queryKey: readonly ["entries", "list"]; queryFn: () => Promise<IEntry[]>; select: (data: IEntry[]) => IEntry[]; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -589,11 +589,11 @@ export const useEntries = () => {
>data.slice(0, 10) : IEntry[]
> : ^^^^^^^^
>data.slice : (start?: number, end?: number) => IEntry[]
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^
>data : IEntry[]
> : ^^^^^^^^
>slice : (start?: number, end?: number) => IEntry[]
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^
>0 : 0
> : ^
>10 : 10
tests/baselines/reference/declarationEmitUsingTypeAlias2.types
+4 -4
View File
@@ -105,10 +105,10 @@ import { goodDeclaration, shouldReuseLocalName, shouldBeElided } from "some-dep"
> : ^^^^^^^^^^^^^
export const bar = goodDeclaration<{}>;
>bar : () => () => { shouldPrintResult: {} extends import("node_modules/some-dep/dist/inner").Other ? "O" : "N"; shouldPrintResult2: {} extends typeof shouldBeElided ? import("node_modules/some-dep/dist/inner").Other : "N"; shouldLookupName: typeof import("node_modules/some-dep/dist/other").shouldLookupName; shouldReuseLocalName: typeof shouldReuseLocalName; reuseDepName: typeof import("node_modules/some-dep/dist/other").reuseDepName; }
> : ^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^
>goodDeclaration<{}> : () => () => { shouldPrintResult: {} extends import("node_modules/some-dep/dist/inner").Other ? "O" : "N"; shouldPrintResult2: {} extends typeof shouldBeElided ? import("node_modules/some-dep/dist/inner").Other : "N"; shouldLookupName: typeof import("node_modules/some-dep/dist/other").shouldLookupName; shouldReuseLocalName: typeof shouldReuseLocalName; reuseDepName: typeof import("node_modules/some-dep/dist/other").reuseDepName; }
> : ^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^
>bar : () => () => { shouldPrintResult: "N"; shouldPrintResult2: "N"; shouldLookupName: typeof import("node_modules/some-dep/dist/other").shouldLookupName; shouldReuseLocalName: typeof shouldReuseLocalName; reuseDepName: typeof import("node_modules/some-dep/dist/other").reuseDepName; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
>goodDeclaration<{}> : () => () => { shouldPrintResult: "N"; shouldPrintResult2: "N"; shouldLookupName: typeof import("node_modules/some-dep/dist/other").shouldLookupName; shouldReuseLocalName: typeof shouldReuseLocalName; reuseDepName: typeof import("node_modules/some-dep/dist/other").reuseDepName; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
>goodDeclaration : <T>() => () => { shouldPrintResult: T extends import("node_modules/some-dep/dist/inner").Other ? "O" : "N"; shouldPrintResult2: T extends typeof shouldBeElided ? import("node_modules/some-dep/dist/inner").Other : "N"; shouldLookupName: typeof import("node_modules/some-dep/dist/other").shouldLookupName; shouldReuseLocalName: typeof shouldReuseLocalName; reuseDepName: typeof import("node_modules/some-dep/dist/other").reuseDepName; }
> : ^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^
tests/baselines/reference/dependentDestructuredVariables.types
+4 -4
View File
@@ -800,11 +800,11 @@ const { value, done } = it.next();
>it.next() : IteratorResult<number, any>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>it.next : (...args: [] | [undefined]) => IteratorResult<number, any>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>it : Iterator<number, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>next : (...args: [] | [undefined]) => IteratorResult<number, any>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
if (!done) {
>!done : boolean
@@ -1086,7 +1086,7 @@ const reducer: (...args: ReducerArgs) => void = (op, args) => {
>args.firstArr.concat(args.secondArr) : any[]
> : ^^^^^
>args.firstArr.concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
>args.firstArr : any[]
> : ^^^^^
>args : { firstArr: any[]; secondArr: any[]; }
@@ -1094,7 +1094,7 @@ const reducer: (...args: ReducerArgs) => void = (op, args) => {
>firstArr : any[]
> : ^^^^^
>concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
>args.secondArr : any[]
> : ^^^^^
>args : { firstArr: any[]; secondArr: any[]; }
tests/baselines/reference/dependentDestructuredVariablesFromNestedPatterns.types
+2 -2
View File
@@ -77,11 +77,11 @@ async function myAllSettled<T extends readonly unknown[]>(fn: () => T) {
>promises.map((result) => result.status === "fulfilled" ? [result.value, undefined] : [undefined, new Error(String(result.reason))], ) : ([undefined, Error] | [unknown, undefined])[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>promises.map : <U>(callbackfn: (value: PromiseSettledResult<unknown>, index: number, array: PromiseSettledResult<unknown>[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>promises : { -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }
> : ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: PromiseSettledResult<unknown>, index: number, array: PromiseSettledResult<unknown>[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>(result) => result.status === "fulfilled" ? [result.value, undefined] : [undefined, new Error(String(result.reason))] : (result: PromiseSettledResult<unknown>) => [undefined, Error] | [unknown, undefined]
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>result : PromiseSettledResult<unknown>
tests/baselines/reference/destructureOfVariableSameAsShorthand.types
+4 -4
View File
@@ -21,13 +21,13 @@ async function main() {
>get().then((response) => { // body is never const body = response.data; }) : Promise<void>
> : ^^^^^^^^^^^^^
>get().then : <TResult1 = AxiosResponse<never>, TResult2 = never>(onfulfilled?: (value: AxiosResponse<never>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>get() : Promise<AxiosResponse<never>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>get : <T = never, R = AxiosResponse<T>>() => Promise<R>
> : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
>then : <TResult1 = AxiosResponse<never>, TResult2 = never>(onfulfilled?: (value: AxiosResponse<never>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>(response) => { // body is never const body = response.data; } : (response: AxiosResponse<never>) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>response : AxiosResponse<never>
@@ -49,13 +49,13 @@ async function main() {
>get().then(({ data }) => { // data is never }) : Promise<void>
> : ^^^^^^^^^^^^^
>get().then : <TResult1 = AxiosResponse<never>, TResult2 = never>(onfulfilled?: (value: AxiosResponse<never>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>get() : Promise<AxiosResponse<never>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>get : <T = never, R = AxiosResponse<T>>() => Promise<R>
> : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
>then : <TResult1 = AxiosResponse<never>, TResult2 = never>(onfulfilled?: (value: AxiosResponse<never>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>({ data }) => { // data is never } : ({ data }: AxiosResponse<never>) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>data : never
tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types
+2 -2
View File
@@ -9,7 +9,7 @@ let { [Symbol.iterator]: destructured } = [];
>iterator : unique symbol
> : ^^^^^^^^^^^^^
>destructured : () => IterableIterator<undefined>
> : ^^^^^^ ^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>[] : undefined[]
> : ^^^^^^^^^^^
@@ -17,7 +17,7 @@ void destructured;
>void destructured : undefined
> : ^^^^^^^^^
>destructured : () => IterableIterator<undefined>
> : ^^^^^^ ^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
const named = "prop";
>named : "prop"
tests/baselines/reference/destructuringAssignmentWithDefault2.types
+4 -4
View File
@@ -174,11 +174,11 @@ let value;
>r.next() : IteratorResult<number, any>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>r.next : (...args: [] | [undefined]) => IteratorResult<number, any>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>r : Iterator<number, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>next : (...args: [] | [undefined]) => IteratorResult<number, any>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
({ done: done = false, value } = r.next());
>({ done: done = false, value } = r.next()) : IteratorResult<number, any>
@@ -200,9 +200,9 @@ let value;
>r.next() : IteratorResult<number, any>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>r.next : (...args: [] | [undefined]) => IteratorResult<number, any>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>r : Iterator<number, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>next : (...args: [] | [undefined]) => IteratorResult<number, any>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/destructuringTuple.types
+4 -4
View File
@@ -63,11 +63,11 @@ const [oops1] = [1, 2, 3].reduce((accu, el) => accu.concat(el), []);
>accu.concat(el) : never[]
> : ^^^^^^^
>accu.concat : { (...items: ConcatArray<never>[]): never[]; (...items: ConcatArray<never>[]): never[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>accu : []
> : ^^
>concat : { (...items: ConcatArray<never>[]): never[]; (...items: ConcatArray<never>[]): never[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>el : number
> : ^^^^^^
>[] : never[]
@@ -99,11 +99,11 @@ const [oops2] = [1, 2, 3].reduce((acc: number[], e) => acc.concat(e), []);
>acc.concat(e) : number[]
> : ^^^^^^^^
>acc.concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>acc : number[]
> : ^^^^^^^^
>concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>e : number
> : ^^^^^^
>[] : never[]
tests/baselines/reference/discriminantsAndPrimitives.types
+4 -4
View File
@@ -260,7 +260,7 @@ if (n.type === "Disjunction") {
>n.alternatives.slice() : string[]
> : ^^^^^^^^
>n.alternatives.slice : (start?: number, end?: number) => string[]
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^
>n.alternatives : string[]
> : ^^^^^^^^
>n : Disjunction
@@ -268,14 +268,14 @@ if (n.type === "Disjunction") {
>alternatives : string[]
> : ^^^^^^^^
>slice : (start?: number, end?: number) => string[]
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^
}
else {
n.elements.slice() // n should be narrowed to Pattern
>n.elements.slice() : string[]
> : ^^^^^^^^
>n.elements.slice : (start?: number, end?: number) => string[]
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^
>n.elements : string[]
> : ^^^^^^^^
>n : Pattern
@@ -283,6 +283,6 @@ else {
>elements : string[]
> : ^^^^^^^^
>slice : (start?: number, end?: number) => string[]
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^
}
tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).types
+18 -18
View File
@@ -27,8 +27,8 @@ function mapAsyncIterable<T, U, R = undefined>(
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterable[Symbol.asyncIterator]() : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterable[Symbol.asyncIterator] : (() => AsyncGenerator<T, R, void>) | (() => AsyncIterator<T>)
> : ^^^^^^^ ^ ^ ^^^^ ^^^^^^^^^^^ ^ ^
>iterable[Symbol.asyncIterator] : (() => AsyncGenerator<T, R, void>) | (() => AsyncIterator<T, any, undefined>)
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterable : AsyncGenerator<T, R, void> | AsyncIterable<T>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Symbol.asyncIterator : unique symbol
@@ -93,11 +93,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^^^^^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^^^^^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"function" : "function"
> : ^^^^^^^^^^
@@ -108,11 +108,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>iterator.return() : Promise<IteratorResult<T, any>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.return : (value?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^^^^^^^^^ ^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>return : (value?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^^^^^^^^^ ^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
} catch (_e) {}
>_e : unknown
@@ -142,11 +142,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>iterator.next() : Promise<IteratorResult<T, any>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.next : (...args: [] | [undefined]) => Promise<IteratorResult<T, any>>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>next : (...args: [] | [undefined]) => Promise<IteratorResult<T, any>>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
},
async return(): Promise<IteratorResult<U, R>> {
@@ -161,11 +161,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^^^^^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^^^^^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"function" : "function"
> : ^^^^^^^^^^
@@ -179,11 +179,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>iterator.return() : Promise<IteratorResult<T, any>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.return : (value?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^^^^^^^^^ ^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>return : (value?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^^^^^^^^^ ^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
: { value: undefined as any, done: true };
>{ value: undefined as any, done: true } : { value: any; done: true; }
@@ -210,11 +210,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>typeof iterator.throw : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.throw : ((e?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^ ^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>throw : ((e?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^ ^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"function" : "function"
> : ^^^^^^^^^^
@@ -228,11 +228,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>iterator.throw(error) : Promise<IteratorResult<T, any>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.throw : (e?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^ ^^^^^ ^ ^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>throw : (e?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^ ^^^^^ ^ ^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>error : unknown
> : ^^^^^^^
}
@@ -310,11 +310,11 @@ const iterable = {
>items.shift() : number | undefined
> : ^^^^^^^^^^^^^^^^^^
>items.shift : () => number | undefined
> : ^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>items : number[]
> : ^^^^^^^^
>shift : () => number | undefined
> : ^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^
return Promise.resolve({
>Promise.resolve({ done: items.length === 0, value, }) : Promise<{ done: boolean; value: number; }>
tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).types
+18 -18
View File
@@ -27,8 +27,8 @@ function mapAsyncIterable<T, U, R = undefined>(
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterable[Symbol.asyncIterator]() : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterable[Symbol.asyncIterator] : (() => AsyncGenerator<T, R, void>) | (() => AsyncIterator<T>)
> : ^^^^^^^ ^ ^ ^^^^ ^^^^^^^^^^^ ^ ^
>iterable[Symbol.asyncIterator] : (() => AsyncGenerator<T, R, void>) | (() => AsyncIterator<T, any, undefined>)
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterable : AsyncGenerator<T, R, void> | AsyncIterable<T>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Symbol.asyncIterator : unique symbol
@@ -93,11 +93,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^^^^^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^^^^^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"function" : "function"
> : ^^^^^^^^^^
@@ -108,11 +108,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>iterator.return() : Promise<IteratorResult<T, any>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.return : (value?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^^^^^^^^^ ^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>return : (value?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^^^^^^^^^ ^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
} catch (_e) {}
>_e : unknown
@@ -142,11 +142,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>iterator.next() : Promise<IteratorResult<T, any>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.next : (...args: [] | [undefined]) => Promise<IteratorResult<T, any>>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>next : (...args: [] | [undefined]) => Promise<IteratorResult<T, any>>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
},
async return(): Promise<IteratorResult<U, R>> {
@@ -161,11 +161,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^^^^^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^^^^^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"function" : "function"
> : ^^^^^^^^^^
@@ -179,11 +179,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>iterator.return() : Promise<IteratorResult<T, any>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.return : (value?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^^^^^^^^^ ^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>return : (value?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^^^^^^^^^ ^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
: { value: undefined as any, done: true };
>{ value: undefined as any, done: true } : { value: any; done: true; }
@@ -210,11 +210,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>typeof iterator.throw : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.throw : ((e?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^ ^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>throw : ((e?: any) => Promise<IteratorResult<T, any>>) | undefined
> : ^^ ^^^ ^^^^^ ^ ^^^ ^^^^^^^^^^^^^
> : ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"function" : "function"
> : ^^^^^^^^^^
@@ -228,11 +228,11 @@ function mapAsyncIterable<T, U, R = undefined>(
>iterator.throw(error) : Promise<IteratorResult<T, any>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator.throw : (e?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^ ^^^^^ ^ ^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>iterator : AsyncIterator<T, any, undefined>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>throw : (e?: any) => Promise<IteratorResult<T, any>>
> : ^ ^^^ ^^^^^ ^ ^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>error : unknown
> : ^^^^^^^
}
@@ -310,11 +310,11 @@ const iterable = {
>items.shift() : number | undefined
> : ^^^^^^^^^^^^^^^^^^
>items.shift : () => number | undefined
> : ^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>items : number[]
> : ^^^^^^^^
>shift : () => number | undefined
> : ^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^
return Promise.resolve({
>Promise.resolve({ done: items.length === 0, value, }) : Promise<{ done: boolean; value: number; }>
tests/baselines/reference/dissallowSymbolAsWeakType.types
+8 -8
View File
@@ -104,12 +104,12 @@ wm.has(s);
wm.get(s);
>wm.get(s) : boolean
> : ^^^^^^^
>wm.get : (key: object) => boolean | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^
>wm.get : (key: object) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^
>wm : WeakMap<object, boolean>
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>get : (key: object) => boolean | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^
>get : (key: object) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^
>s : symbol
> : ^^^^^^
@@ -138,12 +138,12 @@ const wr = new WeakRef(s);
wr.deref();
>wr.deref() : object
> : ^^^^^^
>wr.deref : () => object | undefined
> : ^^^^^^^^^^^^
>wr.deref : () => object
> : ^^^^^^^^^^^^
>wr : WeakRef<object>
> : ^^^^^^^^^^^^^^^
>deref : () => object | undefined
> : ^^^^^^^^^^^^
>deref : () => object
> : ^^^^^^^^^^^^
const f = new FinalizationRegistry(() => {});
>f : FinalizationRegistry<unknown>
tests/baselines/reference/doYouNeedToChangeYourTargetLibraryES2023(target=esnext).types
+20 -20
View File
@@ -72,11 +72,11 @@ export let last1 = array.findLast(somePredicate);
>array.findLast(somePredicate) : number | undefined
> : ^^^^^^^^^^^^^^^^^^
>array.findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>somePredicate : (x: any) => boolean
> : ^ ^^ ^^^^^
@@ -86,11 +86,11 @@ export let last2 = array.findLast(somePredicate);
>array.findLast(somePredicate) : number | undefined
> : ^^^^^^^^^^^^^^^^^^
>array.findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>somePredicate : (x: any) => boolean
> : ^ ^^ ^^^^^
@@ -100,11 +100,11 @@ export let sorted = array.toSorted();
>array.toSorted() : number[]
> : ^^^^^^^^
>array.toSorted : (compareFn?: ((a: number, b: number) => number) | undefined) => number[]
> : ^ ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>toSorted : (compareFn?: ((a: number, b: number) => number) | undefined) => number[]
> : ^ ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
export let spliced1 = array.toSpliced(2);
>spliced1 : number[]
@@ -112,11 +112,11 @@ export let spliced1 = array.toSpliced(2);
>array.toSpliced(2) : number[]
> : ^^^^^^^^
>array.toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>2 : 2
> : ^
@@ -126,11 +126,11 @@ export let spliced2 = array.toSpliced(2, 1);
>array.toSpliced(2, 1) : number[]
> : ^^^^^^^^
>array.toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>2 : 2
> : ^
>1 : 1
@@ -142,11 +142,11 @@ export let spliced3 = array.toSpliced(2, 1, 4, 5, 6, 7);
>array.toSpliced(2, 1, 4, 5, 6, 7) : number[]
> : ^^^^^^^^
>array.toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>2 : 2
> : ^
>1 : 1
@@ -166,11 +166,11 @@ export let spliced4 = array.toSpliced(2, undefined);
>array.toSpliced(2, undefined) : number[]
> : ^^^^^^^^
>array.toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>2 : 2
> : ^
>undefined : undefined
@@ -182,11 +182,11 @@ export let spliced5 = array.toSpliced(2, undefined, 4, 5, 6, 7);
>array.toSpliced(2, undefined, 4, 5, 6, 7) : number[]
> : ^^^^^^^^
>array.toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>2 : 2
> : ^
>undefined : undefined
@@ -206,11 +206,11 @@ export let startsWithOne = array.with(0, 1);
>array.with(0, 1) : number[]
> : ^^^^^^^^
>array.with : (index: number, value: number) => number[]
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>with : (index: number, value: number) => number[]
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
>1 : 1
@@ -222,11 +222,11 @@ export let inTheEnd = array.with(-1, 1);
>array.with(-1, 1) : number[]
> : ^^^^^^^^
>array.with : (index: number, value: number) => number[]
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>with : (index: number, value: number) => number[]
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^
>-1 : -1
> : ^^
>1 : 1
tests/baselines/reference/emitSkipsThisWithRestParameter.types
+2 -2
View File
@@ -31,12 +31,12 @@ function rebase(fn: (base: any, ...args: any[]) => any): (...args: any[]) => any
>[ this ].concat(args) : any[]
> : ^^^^^
>[ this ].concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
>[ this ] : any[]
> : ^^^^^
>this : any
>concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^ ^^^
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
>args : any[]
> : ^^^^^
tests/baselines/reference/emptyArrayDestructuringExpressionVisitedByTransformer.types
+4 -4
View File
@@ -11,13 +11,13 @@ var a = [] = [1].map(_ => _);
>[1].map(_ => _) : number[]
> : ^^^^^^^^
>[1].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[1] : number[]
> : ^^^^^^^^
>1 : 1
> : ^
>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>_ => _ : (_: number) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
>_ : number
@@ -31,13 +31,13 @@ var b = [1].map(_ => _);
>[1].map(_ => _) : number[]
> : ^^^^^^^^
>[1].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[1] : number[]
> : ^^^^^^^^
>1 : 1
> : ^
>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>_ => _ : (_: number) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
>_ : number
tests/baselines/reference/enumIndexer.types
+2 -2
View File
@@ -45,11 +45,11 @@ var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same ty
>_arr.map(o => MyEnumType[o.key] === enumValue) : boolean[]
> : ^^^^^^^^^
>_arr.map : <U>(callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>_arr : { key: string; }[]
> : ^^^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>o => MyEnumType[o.key] === enumValue : (o: { key: string; }) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : { key: string; }
tests/baselines/reference/es2018ObjectAssign.types
+2 -2
View File
@@ -29,9 +29,9 @@ p.finally();
>p.finally() : Promise<number>
> : ^^^^^^^^^^^^^^^
>p.finally : (onfinally?: () => void) => Promise<number>
> : ^ ^^^^^^^^^ ^^^^^ ^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
>p : Promise<number>
> : ^^^^^^^^^^^^^^^
>finally : (onfinally?: () => void) => Promise<number>
> : ^ ^^^^^^^^^ ^^^^^ ^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/esDecorators-contextualTypes.2.types
+2 -2
View File
@@ -6,8 +6,8 @@ class C {
> : ^
@boundMethodLogger("Yadda", /*bound*/ true)
>boundMethodLogger("Yadda", /*bound*/ true) : (target: (this: C) => void, context: ClassMethodDecoratorContext<C, (this: C) => void>) => ((this: C, ...args: []) => void)
> : ^ ^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^
>boundMethodLogger("Yadda", /*bound*/ true) : (target: (this: C) => void, context: ClassMethodDecoratorContext<C, (this: C) => void>) => (this: C) => void
> : ^ ^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^
>boundMethodLogger : <This, Args extends any[], Return>(source: string, bound?: boolean) => (target: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => ((this: This, ...args: Args) => Return)
> : ^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^
>"Yadda" : "Yadda"
tests/baselines/reference/esModuleInteropImportCall.types
+2 -2
View File
@@ -15,13 +15,13 @@ import("./foo").then(f => {
>import("./foo").then(f => { f.default;}) : Promise<void>
> : ^^^^^^^^^^^^^
>import("./foo").then : <TResult1 = { default: () => void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>import("./foo") : Promise<{ default: () => void; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
>"./foo" : "./foo"
> : ^^^^^^^
>then : <TResult1 = { default: () => void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>f => { f.default;} : (f: { default: () => void; }) => void
> : ^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^
>f : { default: () => void; }
tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types
+10 -10
View File
@@ -129,13 +129,13 @@ export class IterableWeakMap<K extends object, V> implements WeakMap<K, V> {
>this.#weakMap.get(key) : { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>this.#weakMap.get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>this.#weakMap : WeakMap<K, { readonly ref: WeakRef<K>; value: V; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^
>this : this
> : ^^^^
>get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>key : K
> : ^
@@ -274,13 +274,13 @@ export class IterableWeakMap<K extends object, V> implements WeakMap<K, V> {
>this.#weakMap.get(key) : { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>this.#weakMap.get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>this.#weakMap : WeakMap<K, { readonly ref: WeakRef<K>; value: V; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^
>this : this
> : ^^^^
>get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>key : K
> : ^
>value : V | undefined
@@ -299,13 +299,13 @@ export class IterableWeakMap<K extends object, V> implements WeakMap<K, V> {
>this.#weakMap.get(key) : { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>this.#weakMap.get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>this.#weakMap : WeakMap<K, { readonly ref: WeakRef<K>; value: V; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^
>this : this
> : ^^^^
>get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>key : K
> : ^
@@ -403,11 +403,11 @@ export class IterableWeakMap<K extends object, V> implements WeakMap<K, V> {
>ref.deref() : K | undefined
> : ^^^^^^^^^^^^^
>ref.deref : () => K | undefined
> : ^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^
>ref : WeakRef<K>
> : ^^^^^^^^^^
>deref : () => K | undefined
> : ^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^
if (key === undefined) continue;
>key === undefined : boolean
@@ -425,13 +425,13 @@ export class IterableWeakMap<K extends object, V> implements WeakMap<K, V> {
>this.#weakMap.get(key) : { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>this.#weakMap.get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>this.#weakMap : WeakMap<K, { readonly ref: WeakRef<K>; value: V; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^
>this : this
> : ^^^^
>get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^
>key : K
> : ^
tests/baselines/reference/excessiveStackDepthFlatArray.types
+3 -3
View File
@@ -1,7 +1,7 @@
//// [tests/cases/compiler/excessiveStackDepthFlatArray.ts] ////
=== Performance Stats ===
Instantiation count: 1,000 -> 2,500
Instantiation count: 1,000
=== index.tsx ===
interface MiddlewareArray<T> extends Array<T> {}
@@ -126,11 +126,11 @@ const Component = () => {
>categories.map((category) => ( <li key={category}>{category}</li> // Error about 'key' only )) : any[]
> : ^^^^^
>categories.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>categories : string[]
> : ^^^^^^^^
>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>(category) => ( <li key={category}>{category}</li> // Error about 'key' only ) : (category: string) => any
> : ^ ^^^^^^^^^^^^^^^^
>category : string
tests/baselines/reference/expressionTypeNodeShouldError.types
+12 -12
View File
@@ -67,12 +67,12 @@ type ItemType = "".typeof(nodes.item(0));
> : ^^^^^^^^^^^^^
>nodes.item(0) : HTMLLIElement
> : ^^^^^^^^^^^^^
>nodes.item : (index: number) => HTMLLIElement | null
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>nodes.item : (index: number) => HTMLLIElement
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>nodes : HTMLCollectionOf<HTMLLIElement>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>item : (index: number) => HTMLLIElement | null
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>item : (index: number) => HTMLLIElement
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
@@ -132,12 +132,12 @@ type ItemType2 = 4..typeof(nodes.item(0));
> : ^^^^^^^^^^^^^
>nodes.item(0) : HTMLLIElement
> : ^^^^^^^^^^^^^
>nodes.item : (index: number) => HTMLLIElement | null
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>nodes.item : (index: number) => HTMLLIElement
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>nodes : HTMLCollectionOf<HTMLLIElement>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>item : (index: number) => HTMLLIElement | null
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>item : (index: number) => HTMLLIElement
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
@@ -201,12 +201,12 @@ type ItemType3 = true.typeof(nodes.item(0));
> : ^^^^^^^^^^^^^
>nodes.item(0) : HTMLLIElement
> : ^^^^^^^^^^^^^
>nodes.item : (index: number) => HTMLLIElement | null
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>nodes.item : (index: number) => HTMLLIElement
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>nodes : HTMLCollectionOf<HTMLLIElement>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>item : (index: number) => HTMLLIElement | null
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>item : (index: number) => HTMLLIElement
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
tests/baselines/reference/extendedInterfaceGenericType.types
+2 -2
View File
@@ -35,11 +35,11 @@ betaOfNumber.takesArgOfT(5);
>betaOfNumber.takesArgOfT(5) : Alpha<number>
> : ^^^^^^^^^^^^^
>betaOfNumber.takesArgOfT : (arg: number) => Alpha<number>
> : ^ ^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
>betaOfNumber : Beta<number>
> : ^^^^^^^^^^^^
>takesArgOfT : (arg: number) => Alpha<number>
> : ^ ^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
>5 : 5
> : ^
tests/baselines/reference/findLast(target=esnext).types
+52 -52
View File
@@ -6,14 +6,14 @@ const itemNumber: number | undefined = [0].findLast((item) => item === 0);
> : ^^^^^^
>[0].findLast((item) => item === 0) : 0
> : ^
>[0].findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^^
>[0].findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^
>[0] : number[]
> : ^^^^^^^^
>0 : 0
> : ^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^
>(item) => item === 0 : (item: number) => item is 0
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
>item : number
@@ -30,14 +30,14 @@ const itemString: string | undefined = ["string"].findLast((item) => item === "s
> : ^^^^^^
>["string"].findLast((item) => item === "string") : "string"
> : ^^^^^^^^
>["string"].findLast : { <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^^
>["string"].findLast : { <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S; (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^
>["string"] : string[]
> : ^^^^^^^^
>"string" : "string"
> : ^^^^^^^^
>findLast : { <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^ ^^^
>findLast : { <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S; (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^
>(item) => item === "string" : (item: string) => item is "string"
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>item : string
@@ -52,14 +52,14 @@ const itemString: string | undefined = ["string"].findLast((item) => item === "s
new Int8Array().findLast((item) => item === 0);
>new Int8Array().findLast((item) => item === 0) : 0
> : ^
>new Int8Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int8Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Int8Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int8Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Int8Array() : Int8Array
> : ^^^^^^^^^
>Int8Array : Int8ArrayConstructor
> : ^^^^^^^^^^^^^^^^^^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Int8Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Int8Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>(item) => item === 0 : (item: number) => item is 0
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
>item : number
@@ -74,14 +74,14 @@ new Int8Array().findLast((item) => item === 0);
new Uint8Array().findLast((item) => item === 0);
>new Uint8Array().findLast((item) => item === 0) : 0
> : ^
>new Uint8Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Uint8Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Uint8Array() : Uint8Array
> : ^^^^^^^^^^
>Uint8Array : Uint8ArrayConstructor
> : ^^^^^^^^^^^^^^^^^^^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>(item) => item === 0 : (item: number) => item is 0
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
>item : number
@@ -96,14 +96,14 @@ new Uint8Array().findLast((item) => item === 0);
new Uint8ClampedArray().findLast((item) => item === 0);
>new Uint8ClampedArray().findLast((item) => item === 0) : 0
> : ^
>new Uint8ClampedArray().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8ClampedArray) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Uint8ClampedArray().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8ClampedArray) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Uint8ClampedArray() : Uint8ClampedArray
> : ^^^^^^^^^^^^^^^^^
>Uint8ClampedArray : Uint8ClampedArrayConstructor
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8ClampedArray) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8ClampedArray) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>(item) => item === 0 : (item: number) => item is 0
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
>item : number
@@ -118,14 +118,14 @@ new Uint8ClampedArray().findLast((item) => item === 0);
new Int16Array().findLast((item) => item === 0);
>new Int16Array().findLast((item) => item === 0) : 0
> : ^
>new Int16Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int16Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Int16Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int16Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Int16Array() : Int16Array
> : ^^^^^^^^^^
>Int16Array : Int16ArrayConstructor
> : ^^^^^^^^^^^^^^^^^^^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Int16Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Int16Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>(item) => item === 0 : (item: number) => item is 0
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
>item : number
@@ -140,14 +140,14 @@ new Int16Array().findLast((item) => item === 0);
new Uint16Array().findLast((item) => item === 0);
>new Uint16Array().findLast((item) => item === 0) : 0
> : ^
>new Uint16Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint16Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Uint16Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint16Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Uint16Array() : Uint16Array
> : ^^^^^^^^^^^
>Uint16Array : Uint16ArrayConstructor
> : ^^^^^^^^^^^^^^^^^^^^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint16Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint16Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>(item) => item === 0 : (item: number) => item is 0
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
>item : number
@@ -162,14 +162,14 @@ new Uint16Array().findLast((item) => item === 0);
new Int32Array().findLast((item) => item === 0);
>new Int32Array().findLast((item) => item === 0) : 0
> : ^
>new Int32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Int32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Int32Array() : Int32Array
> : ^^^^^^^^^^
>Int32Array : Int32ArrayConstructor
> : ^^^^^^^^^^^^^^^^^^^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Int32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Int32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>(item) => item === 0 : (item: number) => item is 0
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
>item : number
@@ -184,14 +184,14 @@ new Int32Array().findLast((item) => item === 0);
new Uint32Array().findLast((item) => item === 0);
>new Uint32Array().findLast((item) => item === 0) : 0
> : ^
>new Uint32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Uint32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Uint32Array() : Uint32Array
> : ^^^^^^^^^^^
>Uint32Array : Uint32ArrayConstructor
> : ^^^^^^^^^^^^^^^^^^^^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>(item) => item === 0 : (item: number) => item is 0
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
>item : number
@@ -206,14 +206,14 @@ new Uint32Array().findLast((item) => item === 0);
new Float32Array().findLast((item) => item === 0);
>new Float32Array().findLast((item) => item === 0) : 0
> : ^
>new Float32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Float32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Float32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Float32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Float32Array() : Float32Array
> : ^^^^^^^^^^^^
>Float32Array : Float32ArrayConstructor
> : ^^^^^^^^^^^^^^^^^^^^^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Float32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Float32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>(item) => item === 0 : (item: number) => item is 0
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
>item : number
@@ -228,14 +228,14 @@ new Float32Array().findLast((item) => item === 0);
new Float64Array().findLast((item) => item === 0);
>new Float64Array().findLast((item) => item === 0) : 0
> : ^
>new Float64Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Float64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Float64Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Float64Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new Float64Array() : Float64Array
> : ^^^^^^^^^^^^
>Float64Array : Float64ArrayConstructor
> : ^^^^^^^^^^^^^^^^^^^^^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Float64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>findLast : { <S extends number>(predicate: (value: number, index: number, array: Float64Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): number | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>(item) => item === 0 : (item: number) => item is 0
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
>item : number
@@ -250,14 +250,14 @@ new Float64Array().findLast((item) => item === 0);
new BigInt64Array().findLast((item) => item === BigInt(0));
>new BigInt64Array().findLast((item) => item === BigInt(0)) : bigint
> : ^^^^^^
>new BigInt64Array().findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigInt64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: bigint, index: number, array: BigInt64Array) => unknown, thisArg?: any): bigint | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new BigInt64Array().findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigInt64Array) => value is S, thisArg?: any): S; (predicate: (value: bigint, index: number, array: BigInt64Array) => unknown, thisArg?: any): bigint | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new BigInt64Array() : BigInt64Array
> : ^^^^^^^^^^^^^
>BigInt64Array : BigInt64ArrayConstructor
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigInt64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: bigint, index: number, array: BigInt64Array) => unknown, thisArg?: any): bigint | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigInt64Array) => value is S, thisArg?: any): S; (predicate: (value: bigint, index: number, array: BigInt64Array) => unknown, thisArg?: any): bigint | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>(item) => item === BigInt(0) : (item: bigint) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^
>item : bigint
@@ -276,14 +276,14 @@ new BigInt64Array().findLast((item) => item === BigInt(0));
new BigUint64Array().findLast((item) => item === BigInt(0));
>new BigUint64Array().findLast((item) => item === BigInt(0)) : bigint
> : ^^^^^^
>new BigUint64Array().findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigUint64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: bigint, index: number, array: BigUint64Array) => unknown, thisArg?: any): bigint | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new BigUint64Array().findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigUint64Array) => value is S, thisArg?: any): S; (predicate: (value: bigint, index: number, array: BigUint64Array) => unknown, thisArg?: any): bigint | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>new BigUint64Array() : BigUint64Array
> : ^^^^^^^^^^^^^^
>BigUint64Array : BigUint64ArrayConstructor
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigUint64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: bigint, index: number, array: BigUint64Array) => unknown, thisArg?: any): bigint | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigUint64Array) => value is S, thisArg?: any): S; (predicate: (value: bigint, index: number, array: BigUint64Array) => unknown, thisArg?: any): bigint | undefined; }
> : ^^^ ^^^^^^^^^ ^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^^
>(item) => item === BigInt(0) : (item: bigint) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^
>item : bigint
tests/baselines/reference/flatArrayNoExcessiveStackDepth.types
+4 -4
View File
@@ -16,12 +16,12 @@ const bar = foo.flatMap(bar => bar as Foo);
> : ^^^^^^^^
>foo.flatMap(bar => bar as Foo) : string[]
> : ^^^^^^^^
>foo.flatMap : <U, This = undefined>(callback: (this: This, value: unknown, index: number, array: unknown[]) => U | ReadonlyArray<U>, thisArg?: This | undefined) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>foo.flatMap : <U, This = undefined>(callback: (this: This, value: unknown, index: number, array: unknown[]) => U | readonly U[], thisArg?: This | undefined) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>foo : unknown[]
> : ^^^^^^^^^
>flatMap : <U, This = undefined>(callback: (this: This, value: unknown, index: number, array: unknown[]) => U | ReadonlyArray<U>, thisArg?: This | undefined) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>flatMap : <U, This = undefined>(callback: (this: This, value: unknown, index: number, array: unknown[]) => U | readonly U[], thisArg?: This | undefined) => U[]
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>bar => bar as Foo : (this: undefined, bar: unknown) => Foo
> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
>bar : unknown
tests/baselines/reference/for-of12.types
+2 -2
View File
@@ -11,7 +11,7 @@ for (v of [0, ""].values()) { }
>[0, ""].values() : IterableIterator<string | number>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>[0, ""].values : () => IterableIterator<string | number>
> : ^^^^^^ ^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>[0, ""] : (string | number)[]
> : ^^^^^^^^^^^^^^^^^^^
>0 : 0
@@ -19,5 +19,5 @@ for (v of [0, ""].values()) { }
>"" : ""
> : ^^
>values : () => IterableIterator<string | number>
> : ^^^^^^ ^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/for-of13.types
+2 -2
View File
@@ -11,11 +11,11 @@ for (v of [""].values()) { }
>[""].values() : IterableIterator<string>
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>[""].values : () => IterableIterator<string>
> : ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>[""] : string[]
> : ^^^^^^^^
>"" : ""
> : ^^
>values : () => IterableIterator<string>
> : ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/formatToPartsFractionalSecond.types
+4 -4
View File
@@ -4,8 +4,8 @@
new Intl.DateTimeFormat().formatToParts().find((val) => val.type === 'fractionalSecond')
>new Intl.DateTimeFormat().formatToParts().find((val) => val.type === 'fractionalSecond') : Intl.DateTimeFormatPart
> : ^^^^^^^^^^^^^^^^^^^^^^^
>new Intl.DateTimeFormat().formatToParts().find : { <S extends Intl.DateTimeFormatPart>(predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => unknown, thisArg?: any): Intl.DateTimeFormatPart | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
>new Intl.DateTimeFormat().formatToParts().find : { <S extends Intl.DateTimeFormatPart>(predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => value is S, thisArg?: any): S; (predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => unknown, thisArg?: any): Intl.DateTimeFormatPart; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>new Intl.DateTimeFormat().formatToParts() : Intl.DateTimeFormatPart[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>new Intl.DateTimeFormat().formatToParts : (date?: Date | number) => Intl.DateTimeFormatPart[]
@@ -20,8 +20,8 @@ new Intl.DateTimeFormat().formatToParts().find((val) => val.type === 'fractional
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>formatToParts : (date?: Date | number) => Intl.DateTimeFormatPart[]
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>find : { <S extends Intl.DateTimeFormatPart>(predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => unknown, thisArg?: any): Intl.DateTimeFormatPart | undefined; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
>find : { <S extends Intl.DateTimeFormatPart>(predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => value is S, thisArg?: any): S; (predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => unknown, thisArg?: any): Intl.DateTimeFormatPart; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>(val) => val.type === 'fractionalSecond' : (val: Intl.DateTimeFormatPart) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>val : Intl.DateTimeFormatPart
tests/baselines/reference/generatorTypeCheck62.types
+6 -6
View File
@@ -75,8 +75,8 @@ export interface State extends StrategicState {
export const Nothing1: Strategy<State> = strategy("Nothing", function*(state: State) {
>Nothing1 : Strategy<State>
> : ^^^^^^^^^^^^^^^
>strategy("Nothing", function*(state: State) { return state;}) : (a: State) => IterableIterator<State | undefined>
> : ^ ^^^^^^^^^^^^ ^^^^^
>strategy("Nothing", function*(state: State) { return state;}) : (a: State) => IterableIterator<State>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^
>"Nothing" : "Nothing"
@@ -95,8 +95,8 @@ export const Nothing1: Strategy<State> = strategy("Nothing", function*(state: St
export const Nothing2: Strategy<State> = strategy("Nothing", function*(state: State) {
>Nothing2 : Strategy<State>
> : ^^^^^^^^^^^^^^^
>strategy("Nothing", function*(state: State) { yield state;}) : (a: State) => IterableIterator<State | undefined>
> : ^ ^^^^^^^^^^^^ ^^^^^
>strategy("Nothing", function*(state: State) { yield state;}) : (a: State) => IterableIterator<State>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^
>"Nothing" : "Nothing"
@@ -117,8 +117,8 @@ export const Nothing2: Strategy<State> = strategy("Nothing", function*(state: St
export const Nothing3: Strategy<State> = strategy("Nothing", function* (state: State) {
>Nothing3 : Strategy<State>
> : ^^^^^^^^^^^^^^^
>strategy("Nothing", function* (state: State) { yield ; return state;}) : (a: any) => IterableIterator<any | undefined>
> : ^ ^^^^^^^^^^ ^^^
>strategy("Nothing", function* (state: State) { yield ; return state;}) : (a: any) => IterableIterator<any>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^
>"Nothing" : "Nothing"
tests/baselines/reference/generatorTypeCheck63.types
+8 -8
View File
@@ -75,8 +75,8 @@ export interface State extends StrategicState {
export const Nothing: Strategy<State> = strategy("Nothing", function* (state: State) {
>Nothing : Strategy<State>
> : ^^^^^^^^^^^^^^^
>strategy("Nothing", function* (state: State) { yield 1; return state;}) : (a: State) => IterableIterator<State | undefined>
> : ^ ^^^^^^^^^^^^ ^^^^^
>strategy("Nothing", function* (state: State) { yield 1; return state;}) : (a: State) => IterableIterator<State>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^
>"Nothing" : "Nothing"
@@ -101,8 +101,8 @@ export const Nothing: Strategy<State> = strategy("Nothing", function* (state: St
export const Nothing1: Strategy<State> = strategy("Nothing", function* (state: State) {
>Nothing1 : Strategy<State>
> : ^^^^^^^^^^^^^^^
>strategy("Nothing", function* (state: State) {}) : (a: State) => IterableIterator<State | undefined>
> : ^ ^^^^^^^^^^^^ ^^^^^
>strategy("Nothing", function* (state: State) {}) : (a: State) => IterableIterator<State>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^
>"Nothing" : "Nothing"
@@ -117,8 +117,8 @@ export const Nothing1: Strategy<State> = strategy("Nothing", function* (state: S
export const Nothing2: Strategy<State> = strategy("Nothing", function* (state: State) {
>Nothing2 : Strategy<State>
> : ^^^^^^^^^^^^^^^
>strategy("Nothing", function* (state: State) { return 1;}) : (a: State) => IterableIterator<State | undefined>
> : ^ ^^^^^^^^^^^^ ^^^^^
>strategy("Nothing", function* (state: State) { return 1;}) : (a: State) => IterableIterator<State>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^
>"Nothing" : "Nothing"
@@ -137,8 +137,8 @@ export const Nothing2: Strategy<State> = strategy("Nothing", function* (state: S
export const Nothing3: Strategy<State> = strategy("Nothing", function* (state: State) {
>Nothing3 : Strategy<State>
> : ^^^^^^^^^^^^^^^
>strategy("Nothing", function* (state: State) { yield state; return 1;}) : (a: State) => IterableIterator<State | undefined>
> : ^ ^^^^^^^^^^^^ ^^^^^
>strategy("Nothing", function* (state: State) { yield state; return 1;}) : (a: State) => IterableIterator<State>
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^
>"Nothing" : "Nothing"
tests/baselines/reference/genericArray1.types
+2 -2
View File
@@ -19,7 +19,7 @@ var lengths = ["a", "b", "c"].map(x => x.length);
>["a", "b", "c"].map(x => x.length) : number[]
> : ^^^^^^^^
>["a", "b", "c"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>["a", "b", "c"] : string[]
> : ^^^^^^^^
>"a" : "a"
@@ -29,7 +29,7 @@ var lengths = ["a", "b", "c"].map(x => x.length);
>"c" : "c"
> : ^^^
>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>x => x.length : (x: string) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
>x : string
tests/baselines/reference/genericArrayMethods1.types
+2 -2
View File
@@ -7,7 +7,7 @@ var x:string[] = [0,1].slice(0); // this should be an error
>[0,1].slice(0) : number[]
> : ^^^^^^^^
>[0,1].slice : (start?: number, end?: number) => number[]
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^
>[0,1] : number[]
> : ^^^^^^^^
>0 : 0
@@ -15,7 +15,7 @@ var x:string[] = [0,1].slice(0); // this should be an error
>1 : 1
> : ^
>slice : (start?: number, end?: number) => number[]
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^
>0 : 0
> : ^
tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.types
+12 -12
View File
@@ -31,11 +31,11 @@ module m1 {
>numPromise.then(testFunction) : Promise<number>
> : ^^^^^^^^^^^^^^^
>numPromise.then : <U>(cb: (x: number) => Promise<U>) => Promise<U>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^^^ ^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>numPromise : Promise<number>
> : ^^^^^^^^^^^^^^^
>then : <U>(cb: (x: number) => Promise<U>) => Promise<U>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^^^ ^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>testFunction : (n: number) => Promise<number>
> : ^ ^^ ^^^^^
}
@@ -78,11 +78,11 @@ module m2 {
>numPromise.then(testFunction) : Promise<string>
> : ^^^^^^^^^^^^^^^
>numPromise.then : <U>(cb: (x: number) => Promise<U>) => Promise<U>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^^^ ^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>numPromise : Promise<number>
> : ^^^^^^^^^^^^^^^
>then : <U>(cb: (x: number) => Promise<U>) => Promise<U>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^^^ ^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>testFunction : { (n: number): Promise<number>; (s: string): Promise<string>; }
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^
}
@@ -131,11 +131,11 @@ module m3 {
>numPromise.then(testFunction) : Promise<number>
> : ^^^^^^^^^^^^^^^
>numPromise.then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^^ ^ ^^^
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>numPromise : Promise<number>
> : ^^^^^^^^^^^^^^^
>then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^^ ^ ^^^
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>testFunction : (n: number) => Promise<number>
> : ^ ^^ ^^^^^
}
@@ -190,11 +190,11 @@ module m4 {
>numPromise.then(testFunction) : Promise<string>
> : ^^^^^^^^^^^^^^^
>numPromise.then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^^ ^ ^^^
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>numPromise : Promise<number>
> : ^^^^^^^^^^^^^^^
>then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^^ ^ ^^^
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>testFunction : { (n: number): Promise<number>; (s: string): Promise<string>; }
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^
}
@@ -265,11 +265,11 @@ module m5 {
>numPromise.then(testFunction) : Promise<string>
> : ^^^^^^^^^^^^^^^
>numPromise.then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => U, progress?: (preservation: any) => void): Promise<U>; }
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^^ ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^ ^^^ ^ ^^^
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^
>numPromise : Promise<number>
> : ^^^^^^^^^^^^^^^
>then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => U, progress?: (preservation: any) => void): Promise<U>; }
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^^ ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^ ^^^ ^ ^^^
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^
>testFunction : { (n: number): Promise<number>; (s: string): Promise<string>; }
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^
}
@@ -330,11 +330,11 @@ module m6 {
>numPromise.then(testFunction) : Promise<boolean>
> : ^^^^^^^^^^^^^^^^
>numPromise.then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^^ ^ ^^^
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>numPromise : Promise<number>
> : ^^^^^^^^^^^^^^^
>then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^^ ^ ^^^
> : ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>testFunction : { (n: number): Promise<number>; (s: string): Promise<string>; (b: boolean): Promise<boolean>; }
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^
}
tests/baselines/reference/genericCallWithinOwnBodyCastTypeParameterIdentity.types
+6 -6
View File
@@ -57,7 +57,7 @@ const toThenable = <Result, Input>(fn: (input: Input) => Result | Thenable<Resul
>toThenable<V, Result>(onFulfilled)(result as Result) : Thenable<V>
> : ^^^^^^^^^^^
>toThenable<V, Result>(onFulfilled) : (input: Result) => Thenable<V>
> : ^ ^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
>toThenable : <Result, Input>(fn: (input: Input) => Result | Thenable<Result>) => (input: Input) => Thenable<Result>
> : ^ ^^ ^^ ^^ ^^^^^^ ^^ ^^^^^
>onFulfilled : (value: Result) => V | Thenable<V>
@@ -98,23 +98,23 @@ const toThenableInferred = <Result, Input>(fn: (input: Input) => Result | Thenab
return {
>{ then(onFulfilled) { return toThenableInferred(onFulfilled)(result as Result) } } : { then<V>(onFulfilled: (value: Result) => V | Thenable<V>): Thenable<V>; }
> : ^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^
> : ^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
then(onFulfilled) {
>then : <V>(onFulfilled: (value: Result) => V | Thenable<V>) => Thenable<V>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>onFulfilled : (value: Result) => V | Thenable<V>
> : ^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return toThenableInferred(onFulfilled)(result as Result)
>toThenableInferred(onFulfilled)(result as Result) : Thenable<V>
> : ^^^^^^^^^^^
>toThenableInferred(onFulfilled) : (input: Result) => Thenable<V>
> : ^ ^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
>toThenableInferred : <Result, Input>(fn: (input: Input) => Result | Thenable<Result>) => (input: Input) => Thenable<Result>
> : ^ ^^ ^^ ^^ ^^^^^^ ^^ ^^^^^
>onFulfilled : (value: Result) => V | Thenable<V>
> : ^ ^^^^^^^^^^^^^^ ^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>result as Result : Result
> : ^^^^^^
>result : Result | Thenable<Result>
tests/baselines/reference/genericChainedCalls.types
+12 -12
View File
@@ -21,19 +21,19 @@ var r1 = v1.func(num => num.toString())
>v1.func(num => num.toString()) .func(str => str.length) // error, number doesn't have a length .func(num => num.toString()) : I1<number>
> : ^^^^^^^^^^
>v1.func(num => num.toString()) .func(str => str.length) // error, number doesn't have a length .func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>v1.func(num => num.toString()) .func(str => str.length) : I1<number>
> : ^^^^^^^^^^
>v1.func(num => num.toString()) .func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>v1.func(num => num.toString()) : I1<number>
> : ^^^^^^^^^^
>v1.func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>v1 : I1<number>
> : ^^^^^^^^^^
>func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>num => num.toString() : (num: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
>num : number
@@ -49,7 +49,7 @@ var r1 = v1.func(num => num.toString())
.func(str => str.length) // error, number doesn't have a length
>func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>str => str.length : (str: number) => any
> : ^ ^^^^^^^^^^^^^^^^
>str : number
@@ -63,7 +63,7 @@ var r1 = v1.func(num => num.toString())
.func(num => num.toString())
>func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>num => num.toString() : (num: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
>num : number
@@ -83,11 +83,11 @@ var s1 = v1.func(num => num.toString())
>v1.func(num => num.toString()) : I1<number>
> : ^^^^^^^^^^
>v1.func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>v1 : I1<number>
> : ^^^^^^^^^^
>func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>num => num.toString() : (num: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
>num : number
@@ -107,11 +107,11 @@ var s2 = s1.func(str => str.length) // should also error
>s1.func(str => str.length) : I1<number>
> : ^^^^^^^^^^
>s1.func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>s1 : I1<number>
> : ^^^^^^^^^^
>func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>str => str.length : (str: number) => any
> : ^ ^^^^^^^^^^^^^^^^
>str : number
@@ -129,11 +129,11 @@ var s3 = s2.func(num => num.toString())
>s2.func(num => num.toString()) : I1<number>
> : ^^^^^^^^^^
>s2.func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>s2 : I1<number>
> : ^^^^^^^^^^
>func : <U>(callback: (value: number) => U) => I1<number>
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>num => num.toString() : (num: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
>num : number
tests/baselines/reference/genericClassWithStaticsUsingTypeArguments.types
+2 -2
View File
@@ -64,11 +64,11 @@ class Foo<T> {
>xs.reverse() : T[]
> : ^^^
>xs.reverse : () => T[]
> : ^^^^^^^
> : ^^^^^^^^^
>xs : T[]
> : ^^^
>reverse : () => T[]
> : ^^^^^^^
> : ^^^^^^^^^
}
}
tests/baselines/reference/genericContextualTypes1.types
+4 -4
View File
@@ -249,11 +249,11 @@ const arrayMap = <T, U>(f: (x: T) => U) => (a: T[]) => a.map(f);
>a.map(f) : U[]
> : ^^^
>a.map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^
>a : T[]
> : ^^^
>map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^
>f : (x: T) => U
> : ^ ^^ ^^^^^
@@ -273,11 +273,11 @@ const arrayFilter = <T>(f: (x: T) => boolean) => (a: T[]) => a.filter(f);
>a.filter(f) : T[]
> : ^^^
>a.filter : { <S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; (predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; }
> : ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^ ^^ ^^^ ^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^
>a : T[]
> : ^^^
>filter : { <S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; (predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; }
> : ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^ ^^ ^^^ ^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^
>f : (x: T) => boolean
> : ^ ^^ ^^^^^
tests/baselines/reference/genericFunctionInference1.types
+31 -31
View File
@@ -561,9 +561,9 @@ declare function pipe2<A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D): (a: [A, C]
const f20 = pipe2(list, box);
>f20 : <T, V>(a: [T, V]) => [T[], { value: V; }]
> : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
>pipe2(list, box) : <T, V>(a: [T, V]) => [T[], { value: V; }]
> : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
>pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>list : <T>(a: T) => T[]
@@ -573,9 +573,9 @@ const f20 = pipe2(list, box);
const f21 = pipe2(box, list);
>f21 : <V, T>(a: [V, T]) => [{ value: V; }, T[]]
> : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^ ^^^ ^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
>pipe2(box, list) : <V, T>(a: [V, T]) => [{ value: V; }, T[]]
> : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^ ^^^ ^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
>pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>box : <V>(x: V) => { value: V; }
@@ -585,9 +585,9 @@ const f21 = pipe2(box, list);
const f22 = pipe2(list, list);
>f22 : <T, T1>(a: [T, T1]) => [T[], T1[]]
> : ^ ^^^^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>pipe2(list, list) : <T, T1>(a: [T, T1]) => [T[], T1[]]
> : ^ ^^^^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>list : <T>(a: T) => T[]
@@ -597,9 +597,9 @@ const f22 = pipe2(list, list);
const f23 = pipe2(box, box);
>f23 : <V, V1>(a: [V, V1]) => [{ value: V; }, { value: V1; }]
> : ^ ^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
>pipe2(box, box) : <V, V1>(a: [V, V1]) => [{ value: V; }, { value: V1; }]
> : ^ ^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
>pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>box : <V>(x: V) => { value: V; }
@@ -609,21 +609,21 @@ const f23 = pipe2(box, box);
const f24 = pipe2(f20, f20);
>f24 : <T, V, T1, V1>(a: [[T, V], [T1, V1]]) => [[T[], { value: V; }], [T1[], { value: V1; }]]
> : ^ ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>pipe2(f20, f20) : <T, V, T1, V1>(a: [[T, V], [T1, V1]]) => [[T[], { value: V; }], [T1[], { value: V1; }]]
> : ^ ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>f20 : <T, V>(a: [T, V]) => [T[], { value: V; }]
> : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
>f20 : <T, V>(a: [T, V]) => [T[], { value: V; }]
> : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
const f25 = pipe2(foo, foo);
>f25 : <T extends { value: T; }, T1 extends { value: T1; }>(a: [T, T1]) => [T, T1]
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^ ^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
>pipe2(foo, foo) : <T extends { value: T; }, T1 extends { value: T1; }>(a: [T, T1]) => [T, T1]
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^ ^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
>pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>foo : <T extends { value: T; }>(x: T) => T
@@ -633,15 +633,15 @@ const f25 = pipe2(foo, foo);
const f26 = pipe2(f25, f25);
>f26 : <T extends { value: T; }, T1 extends { value: T1; }, T2 extends { value: T2; }, T3 extends { value: T3; }>(a: [[T, T1], [T2, T3]]) => [[T, T1], [T2, T3]]
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>pipe2(f25, f25) : <T extends { value: T; }, T1 extends { value: T1; }, T2 extends { value: T2; }, T3 extends { value: T3; }>(a: [[T, T1], [T2, T3]]) => [[T, T1], [T2, T3]]
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>f25 : <T extends { value: T; }, T1 extends { value: T1; }>(a: [T, T1]) => [T, T1]
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^ ^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
>f25 : <T extends { value: T; }, T1 extends { value: T1; }>(a: [T, T1]) => [T, T1]
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^ ^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
declare function pipe3<A, B, C>(ab: (a: A) => B, ac: (a: A) => C): (a: A) => [B, C];
>pipe3 : <A, B, C>(ab: (a: A) => B, ac: (a: A) => C) => (a: A) => [B, C]
@@ -659,9 +659,9 @@ declare function pipe3<A, B, C>(ab: (a: A) => B, ac: (a: A) => C): (a: A) => [B,
const f30 = pipe3(list, box);
>f30 : <T>(a: T) => [T[], { value: T; }]
> : ^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>pipe3(list, box) : <T>(a: T) => [T[], { value: T; }]
> : ^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>pipe3 : <A, B, C>(ab: (a: A) => B, ac: (a: A) => C) => (a: A) => [B, C]
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>list : <T>(a: T) => T[]
@@ -671,9 +671,9 @@ const f30 = pipe3(list, box);
const f31 = pipe3(box, list);
>f31 : <V>(a: V) => [{ value: V; }, V[]]
> : ^ ^^ ^^^^^^^^ ^^^^^^^^^ ^^^ ^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
>pipe3(box, list) : <V>(a: V) => [{ value: V; }, V[]]
> : ^ ^^ ^^^^^^^^ ^^^^^^^^^ ^^^ ^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
>pipe3 : <A, B, C>(ab: (a: A) => B, ac: (a: A) => C) => (a: A) => [B, C]
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>box : <V>(x: V) => { value: V; }
@@ -683,9 +683,9 @@ const f31 = pipe3(box, list);
const f32 = pipe3(list, list);
>f32 : <T>(a: T) => [T[], T[]]
> : ^ ^^ ^^^^^^^^ ^^^ ^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>pipe3(list, list) : <T>(a: T) => [T[], T[]]
> : ^ ^^ ^^^^^^^^ ^^^ ^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>pipe3 : <A, B, C>(ab: (a: A) => B, ac: (a: A) => C) => (a: A) => [B, C]
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>list : <T>(a: T) => T[]
@@ -1008,9 +1008,9 @@ declare class GenericComp<T> extends Comp<GenericProps<T>> {}
const GenericComp2 = myHoc(GenericComp);
>GenericComp2 : new <T>(props: GenericProps<T>) => Comp<GenericProps<T>>
> : ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
> : ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>myHoc(GenericComp) : new <T>(props: GenericProps<T>) => Comp<GenericProps<T>>
> : ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
> : ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>myHoc : <P>(C: CompClass<P>) => CompClass<P>
> : ^ ^^ ^^ ^^^^^
>GenericComp : typeof GenericComp
@@ -1213,11 +1213,11 @@ const map = <T, U>(transform: (t: T) => U) =>
>arr.map(transform) : U[]
> : ^^^
>arr.map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^
>arr : T[]
> : ^^^
>map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
> : ^^^^^^ ^^^ ^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^
>transform : (t: T) => U
> : ^ ^^ ^^^^^
@@ -1422,11 +1422,11 @@ promise.then(
>promise.then( pipe( x => x + 1, x => x * 2, ),) : Promise<number>
> : ^^^^^^^^^^^^^^^
>promise.then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>promise : Promise<number>
> : ^^^^^^^^^^^^^^^
>then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
pipe(
>pipe( x => x + 1, x => x * 2, ) : (x: number) => number
@@ -1659,7 +1659,7 @@ const a2 = times(identity)(5); // => [0, 1, 2, 3, 4]
>times(identity)(5) : number[]
> : ^^^^^^^^
>times(identity) : (n: number) => number[]
> : ^ ^^ ^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^
>times : <T>(fn: (i: number) => T) => (n: number) => T[]
> : ^ ^^ ^^ ^^^^^
>identity : <T>(value: T) => T
tests/baselines/reference/genericFunctionsAndConditionalInference.types
+4 -4
View File
@@ -141,11 +141,11 @@ const ok = <F extends Target>(at: Ops<F>) => ({lr: at.lr(at.str, at.num)})
>at.lr(at.str, at.num) : Result<F, LR<F, string, number>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>at.lr : <I, O>(a: Result<F, I>, o: Result<F, O>) => Result<F, LR<F, I, O>>
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^ ^ ^ ^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>at : Ops<F>
> : ^^^^^^
>lr : <I, O>(a: Result<F, I>, o: Result<F, O>) => Result<F, LR<F, I, O>>
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^ ^ ^ ^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>at.str : Result<F, string>
> : ^^^^^^^^^^^^^^^^^
>at : Ops<F>
@@ -169,11 +169,11 @@ const orphaned = <F extends Target>(at: Ops<F>) => at.dict(ok(at))
>at.dict(ok(at)) : Result<F, { lr: LR<F, string, number>; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>at.dict : <P>(p: { [k in keyof P]: Result<F, P[k]>; }) => Result<F, P>
> : ^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^
> : ^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>at : Ops<F>
> : ^^^^^^
>dict : <P>(p: { [k in keyof P]: Result<F, P[k]>; }) => Result<F, P>
> : ^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^
> : ^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>ok(at) : { lr: Result<F, LR<F, string, number>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>ok : <F_1 extends Target>(at: Ops<F_1>) => { lr: Result<F_1, LR<F_1, string, number>>; }
tests/baselines/reference/genericInference1.types
+2 -2
View File
@@ -5,7 +5,7 @@
>['a', 'b', 'c'].map(x => x.length) : number[]
> : ^^^^^^^^
>['a', 'b', 'c'].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>['a', 'b', 'c'] : string[]
> : ^^^^^^^^
>'a' : "a"
@@ -15,7 +15,7 @@
>'c' : "c"
> : ^^^
>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>x => x.length : (x: string) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
>x : string
tests/baselines/reference/genericMethodOverspecialization.types
+6 -6
View File
@@ -45,11 +45,11 @@ var elements = names.map(function (name) {
>names.map(function (name) { return document.getElementById(name);}) : HTMLElement[]
> : ^^^^^^^^^^^^^
>names.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>names : string[]
> : ^^^^^^^^
>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>function (name) { return document.getElementById(name);} : (name: string) => HTMLElement
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
>name : string
@@ -76,11 +76,11 @@ var xxx = elements.filter(function (e) {
>elements.filter(function (e) { return !e.isDisabled;}) : HTMLElement[]
> : ^^^^^^^^^^^^^
>elements.filter : { <S extends HTMLElement>(predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => unknown, thisArg?: any): HTMLElement[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^
>elements : HTMLElement[]
> : ^^^^^^^^^^^^^
>filter : { <S extends HTMLElement>(predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => unknown, thisArg?: any): HTMLElement[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^
>function (e) { return !e.isDisabled;} : (e: HTMLElement) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>e : HTMLElement
@@ -104,11 +104,11 @@ var widths:number[] = elements.map(function (e) { // should not error
>elements.map(function (e) { // should not error return e.clientWidth;}) : number[]
> : ^^^^^^^^
>elements.map : <U>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>elements : HTMLElement[]
> : ^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>function (e) { // should not error return e.clientWidth;} : (e: HTMLElement) => number
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
>e : HTMLElement
tests/baselines/reference/genericReduce.types
+2 -2
View File
@@ -21,11 +21,11 @@ var b = a.map(s => s.length);
>a.map(s => s.length) : number[]
> : ^^^^^^^^
>a.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>a : string[]
> : ^^^^^^^^
>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>s => s.length : (s: string) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
>s : string
tests/baselines/reference/genericReversingTypeParameters.types
+2 -2
View File
@@ -48,11 +48,11 @@ var i = b.inverse(); // used to get the type wrong here.
>b.inverse() : BiMap<number, string>
> : ^^^^^^^^^^^^^^^^^^^^^
>b.inverse : () => BiMap<number, string>
> : ^^^^^^ ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>b : BiMap<string, number>
> : ^^^^^^^^^^^^^^^^^^^^^
>inverse : () => BiMap<number, string>
> : ^^^^^^ ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
var r2b = i.get(1);
>r2b : string
tests/baselines/reference/genericReversingTypeParameters2.types
+2 -2
View File
@@ -34,11 +34,11 @@ var i = b.inverse(); // used to get the type wrong here.
>b.inverse() : BiMap<number, string>
> : ^^^^^^^^^^^^^^^^^^^^^
>b.inverse : () => BiMap<number, string>
> : ^^^^^^ ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>b : BiMap<string, number>
> : ^^^^^^^^^^^^^^^^^^^^^
>inverse : () => BiMap<number, string>
> : ^^^^^^ ^^^^^^ ^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
var r2b = i.get(1);
>r2b : string
tests/baselines/reference/genericTypeParameterEquivalence2.types
+4 -4
View File
@@ -204,9 +204,9 @@ function curry1<A, B, C>(f: (a: A, b: B) => C): (ax: A) => (bx: B) => C {
var cfilter = curry1(filter);
>cfilter : <A>(ax: (a: A) => boolean) => (bx: A[]) => A[]
> : ^ ^^ ^^^ ^^ ^^^^^ ^^^^^ ^^^ ^^^
> : ^ ^^ ^^^ ^^ ^^^^^ ^^^^^^ ^^^^^^^^^^^^^
>curry1(filter) : <A>(ax: (a: A) => boolean) => (bx: A[]) => A[]
> : ^ ^^ ^^^ ^^ ^^^^^ ^^^^^ ^^^ ^^^
> : ^ ^^ ^^^ ^^ ^^^^^ ^^^^^^ ^^^^^^^^^^^^^
>curry1 : <A, B, C>(f: (a: A, b: B) => C) => (ax: A) => (bx: B) => C
> : ^ ^^ ^^ ^^ ^^ ^^^^^
>filter : <A>(f: (a: A) => boolean, ar: A[]) => A[]
@@ -240,7 +240,7 @@ function countWhere_1<A>(pred: (a: A) => boolean): (a: A[]) => number {
>cfilter(pred) : (bx: A[]) => A[]
> : ^ ^^^^^^^^^^^^^
>cfilter : <A_1>(ax: (a: A_1) => boolean) => (bx: A_1[]) => A_1[]
> : ^^^^^^ ^^^ ^^ ^^^^^ ^^^^^ ^^^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^
>pred : (a: A) => boolean
> : ^ ^^ ^^^^^
}
@@ -261,7 +261,7 @@ function countWhere_2<A>(pred: (a: A) => boolean): (a: A[]) => number {
>cfilter(pred) : (bx: A[]) => A[]
> : ^ ^^^^^^^^^^^^^
>cfilter : <A_1>(ax: (a: A_1) => boolean) => (bx: A_1[]) => A_1[]
> : ^^^^^^ ^^^ ^^ ^^^^^ ^^^^^ ^^^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^
>pred : (a: A) => boolean
> : ^ ^^ ^^^^^
tests/baselines/reference/genericsAndHigherOrderFunctions.types
+1 -1
View File
@@ -121,7 +121,7 @@ var foo: <K, N>(g: (x: K) => N) =>
>combine(f)(g) : (x: K) => (_: R) => R
> : ^ ^^^^^^^^^ ^^ ^^^^^
>combine(f) : <U>(g: (_: U) => N) => (x: U) => (_: R) => R
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^ ^ ^ ^^ ^^^^^
> : ^ ^^ ^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^ ^^^^^
>combine : <T, S>(f: (_: T) => S) => <U>(g: (_: U) => T) => (x: U) => S
> : ^ ^^ ^^ ^^ ^^^^^
>f : (_: N) => (_: R) => R

Some files were not shown because too many files have changed in this diff Show More