From a1df1aee226a2611a5dcb396bcdbac74fae04095 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 7 Sep 2023 22:19:26 -0700 Subject: [PATCH 1/6] Add test --- ...rationEmitTypeParameterNameInOuterScope.js | 43 +++++++++++++++ ...nEmitTypeParameterNameInOuterScope.symbols | 52 +++++++++++++++++++ ...ionEmitTypeParameterNameInOuterScope.types | 44 ++++++++++++++++ ...rationEmitTypeParameterNameInOuterScope.ts | 16 ++++++ 4 files changed, 155 insertions(+) create mode 100644 tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.js create mode 100644 tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.symbols create mode 100644 tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.types create mode 100644 tests/cases/compiler/declarationEmitTypeParameterNameInOuterScope.ts diff --git a/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.js b/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.js new file mode 100644 index 0000000000000..bddfc9a119a89 --- /dev/null +++ b/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.js @@ -0,0 +1,43 @@ +//// [tests/cases/compiler/declarationEmitTypeParameterNameInOuterScope.ts] //// + +//// [declarationEmitTypeParameterNameInOuterScope.ts] +class A { } + +var a = (x: A) => x; +function a2(x: A) { return x } + +var a3 = (x: A) => new A(); +function a4(x: A) { return new A() } + + +interface B { } + +var b = (x: B) => x; +function b2(x: B) { return x } + + +//// [declarationEmitTypeParameterNameInOuterScope.js] +var A = /** @class */ (function () { + function A() { + } + return A; +}()); +var a = function (x) { return x; }; +function a2(x) { return x; } +var a3 = function (x) { return new A(); }; +function a4(x) { return new A(); } +var b = function (x) { return x; }; +function b2(x) { return x; } + + +//// [declarationEmitTypeParameterNameInOuterScope.d.ts] +declare class A { +} +declare var a: (x: A_1) => A_1; +declare function a2(x: A): A; +declare var a3: (x: A_1) => A; +declare function a4(x: A): globalThis.A; +interface B { +} +declare var b: (x: B_1) => B_1; +declare function b2(x: B): B; diff --git a/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.symbols b/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.symbols new file mode 100644 index 0000000000000..4605797b8547b --- /dev/null +++ b/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.symbols @@ -0,0 +1,52 @@ +//// [tests/cases/compiler/declarationEmitTypeParameterNameInOuterScope.ts] //// + +=== declarationEmitTypeParameterNameInOuterScope.ts === +class A { } +>A : Symbol(A, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 0, 0)) + +var a = (x: A) => x; +>a : Symbol(a, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 2, 3)) +>A : Symbol(A, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 2, 9)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 2, 13)) +>A : Symbol(A, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 2, 9)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 2, 13)) + +function a2(x: A) { return x } +>a2 : Symbol(a2, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 2, 24)) +>A : Symbol(A, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 3, 12)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 3, 16)) +>A : Symbol(A, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 3, 12)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 3, 16)) + +var a3 = (x: A) => new A(); +>a3 : Symbol(a3, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 5, 3)) +>A : Symbol(A, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 5, 10)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 5, 14)) +>A : Symbol(A, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 5, 10)) +>A : Symbol(A, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 0, 0)) + +function a4(x: A) { return new A() } +>a4 : Symbol(a4, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 5, 31)) +>A : Symbol(A, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 6, 12)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 6, 16)) +>A : Symbol(A, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 6, 12)) +>A : Symbol(A, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 0, 0)) + + +interface B { } +>B : Symbol(B, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 6, 40)) + +var b = (x: B) => x; +>b : Symbol(b, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 11, 3)) +>B : Symbol(B, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 11, 9)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 11, 13)) +>B : Symbol(B, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 11, 9)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 11, 13)) + +function b2(x: B) { return x } +>b2 : Symbol(b2, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 11, 24)) +>B : Symbol(B, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 12, 12)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 12, 16)) +>B : Symbol(B, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 12, 12)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameInOuterScope.ts, 12, 16)) + diff --git a/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.types b/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.types new file mode 100644 index 0000000000000..018e04b6d7ee7 --- /dev/null +++ b/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/declarationEmitTypeParameterNameInOuterScope.ts] //// + +=== declarationEmitTypeParameterNameInOuterScope.ts === +class A { } +>A : A + +var a = (x: A) => x; +>a : (x: A_1) => A_1 +>(x: A) => x : (x: A_1) => A_1 +>x : A +>x : A + +function a2(x: A) { return x } +>a2 : (x: A) => A +>x : A +>x : A + +var a3 = (x: A) => new A(); +>a3 : (x: A_1) => A +>(x: A) => new A() : (x: A_1) => A +>x : A +>new A() : globalThis.A +>A : typeof A + +function a4(x: A) { return new A() } +>a4 : (x: A) => globalThis.A +>x : A +>new A() : globalThis.A +>A : typeof A + + +interface B { } + +var b = (x: B) => x; +>b : (x: B_1) => B_1 +>(x: B) => x : (x: B_1) => B_1 +>x : B +>x : B + +function b2(x: B) { return x } +>b2 : (x: B) => B +>x : B +>x : B + diff --git a/tests/cases/compiler/declarationEmitTypeParameterNameInOuterScope.ts b/tests/cases/compiler/declarationEmitTypeParameterNameInOuterScope.ts new file mode 100644 index 0000000000000..10e18f43d4d84 --- /dev/null +++ b/tests/cases/compiler/declarationEmitTypeParameterNameInOuterScope.ts @@ -0,0 +1,16 @@ +// @declaration: true +// @skipLibCheck: false + +class A { } + +var a = (x: A) => x; +function a2(x: A) { return x } + +var a3 = (x: A) => new A(); +function a4(x: A) { return new A() } + + +interface B { } + +var b = (x: B) => x; +function b2(x: B) { return x } From ae910313e5f660c25dd2c25003ee69353a7606ac Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 21 Sep 2023 19:06:15 -0700 Subject: [PATCH 2/6] Add interesting test from other bug investigation --- ...nEmitTypeParameterNameReusedInOverloads.js | 82 +++++++++++++++++++ ...TypeParameterNameReusedInOverloads.symbols | 58 +++++++++++++ ...itTypeParameterNameReusedInOverloads.types | 42 ++++++++++ ...nEmitTypeParameterNameReusedInOverloads.ts | 17 ++++ 4 files changed, 199 insertions(+) create mode 100644 tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.js create mode 100644 tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.symbols create mode 100644 tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.types create mode 100644 tests/cases/compiler/declarationEmitTypeParameterNameReusedInOverloads.ts diff --git a/tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.js b/tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.js new file mode 100644 index 0000000000000..7cb7af37bd3a2 --- /dev/null +++ b/tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.js @@ -0,0 +1,82 @@ +//// [tests/cases/compiler/declarationEmitTypeParameterNameReusedInOverloads.ts] //// + +//// [declarationEmitTypeParameterNameReusedInOverloads.ts] +export class Base { foo: string; } +export class Derived extends Base { bar: string; } +export class Derived2 extends Derived { baz: string; } + +export type Foo = { + new (x: { + new (a: T): T; + new (a: T): T; + }): any[]; + new (x: { + new (a: T): T; + new (a: T): T; + }): any[]; +} + + +//// [declarationEmitTypeParameterNameReusedInOverloads.js] +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Derived2 = exports.Derived = exports.Base = void 0; +var Base = /** @class */ (function () { + function Base() { + } + return Base; +}()); +exports.Base = Base; +var Derived = /** @class */ (function (_super) { + __extends(Derived, _super); + function Derived() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Derived; +}(Base)); +exports.Derived = Derived; +var Derived2 = /** @class */ (function (_super) { + __extends(Derived2, _super); + function Derived2() { + return _super !== null && _super.apply(this, arguments) || this; + } + return Derived2; +}(Derived)); +exports.Derived2 = Derived2; + + +//// [declarationEmitTypeParameterNameReusedInOverloads.d.ts] +export declare class Base { + foo: string; +} +export declare class Derived extends Base { + bar: string; +} +export declare class Derived2 extends Derived { + baz: string; +} +export type Foo = { + new (x: { + new (a: T): T; + new (a: T): T; + }): any[]; + new (x: { + new (a: T): T; + new (a: T): T; + }): any[]; +}; diff --git a/tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.symbols b/tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.symbols new file mode 100644 index 0000000000000..2f803de250dc7 --- /dev/null +++ b/tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.symbols @@ -0,0 +1,58 @@ +//// [tests/cases/compiler/declarationEmitTypeParameterNameReusedInOverloads.ts] //// + +=== declarationEmitTypeParameterNameReusedInOverloads.ts === +export class Base { foo: string; } +>Base : Symbol(Base, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 0, 0)) +>foo : Symbol(Base.foo, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 0, 19)) + +export class Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 0, 34)) +>Base : Symbol(Base, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 0, 0)) +>bar : Symbol(Derived.bar, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 1, 35)) + +export class Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 1, 50)) +>Derived : Symbol(Derived, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 0, 34)) +>baz : Symbol(Derived2.baz, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 2, 39)) + +export type Foo = { +>Foo : Symbol(Foo, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 2, 54)) + + new (x: { +>x : Symbol(x, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 5, 9)) + + new (a: T): T; +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 6, 13)) +>Derived : Symbol(Derived, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 0, 34)) +>a : Symbol(a, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 6, 32)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 6, 13)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 6, 13)) + + new (a: T): T; +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 7, 13)) +>Base : Symbol(Base, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 0, 0)) +>a : Symbol(a, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 7, 29)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 7, 13)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 7, 13)) + + }): any[]; + new (x: { +>x : Symbol(x, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 9, 9)) + + new (a: T): T; +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 10, 13)) +>Derived2 : Symbol(Derived2, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 1, 50)) +>a : Symbol(a, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 10, 33)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 10, 13)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 10, 13)) + + new (a: T): T; +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 11, 17)) +>Base : Symbol(Base, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 0, 0)) +>a : Symbol(a, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 11, 33)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 11, 17)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameReusedInOverloads.ts, 11, 17)) + + }): any[]; +} + diff --git a/tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.types b/tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.types new file mode 100644 index 0000000000000..e6cc3fc829bd6 --- /dev/null +++ b/tests/baselines/reference/declarationEmitTypeParameterNameReusedInOverloads.types @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/declarationEmitTypeParameterNameReusedInOverloads.ts] //// + +=== declarationEmitTypeParameterNameReusedInOverloads.ts === +export class Base { foo: string; } +>Base : Base +>foo : string + +export class Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + +export class Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + +export type Foo = { +>Foo : { new (x: { new (a: T): T; new (a: T_1): T_1; }): any[]; new (x: { new (a: T_2): T_2; new (a: T_3): T_3; }): any[]; } + + new (x: { +>x : { new (a: T): T; new (a: T_1): T_1; } + + new (a: T): T; +>a : T + + new (a: T): T; +>a : T + + }): any[]; + new (x: { +>x : { new (a: T): T; new (a: T_1): T_1; } + + new (a: T): T; +>a : T + + new (a: T): T; +>a : T + + }): any[]; +} + diff --git a/tests/cases/compiler/declarationEmitTypeParameterNameReusedInOverloads.ts b/tests/cases/compiler/declarationEmitTypeParameterNameReusedInOverloads.ts new file mode 100644 index 0000000000000..a30b54eef5adc --- /dev/null +++ b/tests/cases/compiler/declarationEmitTypeParameterNameReusedInOverloads.ts @@ -0,0 +1,17 @@ +// @declaration: true +// @skipLibCheck: false + +export class Base { foo: string; } +export class Derived extends Base { bar: string; } +export class Derived2 extends Derived { baz: string; } + +export type Foo = { + new (x: { + new (a: T): T; + new (a: T): T; + }): any[]; + new (x: { + new (a: T): T; + new (a: T): T; + }): any[]; +} From d8caed42be1ee227f37c5941329e33e8fa46eec2 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 24 Sep 2023 15:27:18 -0700 Subject: [PATCH 3/6] Add new test case which breaks with this code --- ...EmitTypeParameterNameShadowedInternally.js | 22 +++++++++++++++++++ ...ypeParameterNameShadowedInternally.symbols | 22 +++++++++++++++++++ ...tTypeParameterNameShadowedInternally.types | 21 ++++++++++++++++++ ...EmitTypeParameterNameShadowedInternally.ts | 7 ++++++ 4 files changed, 72 insertions(+) create mode 100644 tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.js create mode 100644 tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.symbols create mode 100644 tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.types create mode 100644 tests/cases/compiler/declarationEmitTypeParameterNameShadowedInternally.ts diff --git a/tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.js b/tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.js new file mode 100644 index 0000000000000..ebc5136e73979 --- /dev/null +++ b/tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.js @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/declarationEmitTypeParameterNameShadowedInternally.ts] //// + +//// [declarationEmitTypeParameterNameShadowedInternally.ts] +export const foo = (x: T) => { + const inner = (y: T) => [x, y] as const; + return inner; +} + + +//// [declarationEmitTypeParameterNameShadowedInternally.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.foo = void 0; +var foo = function (x) { + var inner = function (y) { return [x, y]; }; + return inner; +}; +exports.foo = foo; + + +//// [declarationEmitTypeParameterNameShadowedInternally.d.ts] +export declare const foo: (x: T) => (y: T_1) => readonly [T, T_1]; diff --git a/tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.symbols b/tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.symbols new file mode 100644 index 0000000000000..09b0c3cb3f18f --- /dev/null +++ b/tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.symbols @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/declarationEmitTypeParameterNameShadowedInternally.ts] //// + +=== declarationEmitTypeParameterNameShadowedInternally.ts === +export const foo = (x: T) => { +>foo : Symbol(foo, Decl(declarationEmitTypeParameterNameShadowedInternally.ts, 0, 12)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameShadowedInternally.ts, 0, 20)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameShadowedInternally.ts, 0, 24)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameShadowedInternally.ts, 0, 20)) + + const inner = (y: T) => [x, y] as const; +>inner : Symbol(inner, Decl(declarationEmitTypeParameterNameShadowedInternally.ts, 1, 6)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameShadowedInternally.ts, 1, 16)) +>y : Symbol(y, Decl(declarationEmitTypeParameterNameShadowedInternally.ts, 1, 20)) +>T : Symbol(T, Decl(declarationEmitTypeParameterNameShadowedInternally.ts, 1, 16)) +>x : Symbol(x, Decl(declarationEmitTypeParameterNameShadowedInternally.ts, 0, 24)) +>y : Symbol(y, Decl(declarationEmitTypeParameterNameShadowedInternally.ts, 1, 20)) +>const : Symbol(const) + + return inner; +>inner : Symbol(inner, Decl(declarationEmitTypeParameterNameShadowedInternally.ts, 1, 6)) +} + diff --git a/tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.types b/tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.types new file mode 100644 index 0000000000000..5c47cb56446fe --- /dev/null +++ b/tests/baselines/reference/declarationEmitTypeParameterNameShadowedInternally.types @@ -0,0 +1,21 @@ +//// [tests/cases/compiler/declarationEmitTypeParameterNameShadowedInternally.ts] //// + +=== declarationEmitTypeParameterNameShadowedInternally.ts === +export const foo = (x: T) => { +>foo : (x: T) => (y: T_1) => readonly [T, T_1] +>(x: T) => { const inner = (y: T) => [x, y] as const; return inner;} : (x: T) => (y: T_1) => readonly [T, T_1] +>x : T + + const inner = (y: T) => [x, y] as const; +>inner : (y: T_1) => readonly [T, T_1] +>(y: T) => [x, y] as const : (y: T_1) => readonly [T, T_1] +>y : T +>[x, y] as const : readonly [T_1, T] +>[x, y] : readonly [T_1, T] +>x : T_1 +>y : T + + return inner; +>inner : (y: T_1) => readonly [T, T_1] +} + diff --git a/tests/cases/compiler/declarationEmitTypeParameterNameShadowedInternally.ts b/tests/cases/compiler/declarationEmitTypeParameterNameShadowedInternally.ts new file mode 100644 index 0000000000000..2c0b6bffd7fe8 --- /dev/null +++ b/tests/cases/compiler/declarationEmitTypeParameterNameShadowedInternally.ts @@ -0,0 +1,7 @@ +// @declaration: true +// @skipLibCheck: false + +export const foo = (x: T) => { + const inner = (y: T) => [x, y] as const; + return inner; +} From d13fa9495cd51b086842b77685f054b5cfb81127 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 9 Oct 2023 14:13:25 -0700 Subject: [PATCH 4/6] Add test case from PR 56046 Co-authored-by: Wesley Wigham --- ...clarationEmitReusesLambdaParameterNodes.js | 27 ++++++++++++++ ...tionEmitReusesLambdaParameterNodes.symbols | 37 +++++++++++++++++++ ...rationEmitReusesLambdaParameterNodes.types | 24 ++++++++++++ ...clarationEmitReusesLambdaParameterNodes.ts | 12 ++++++ 4 files changed, 100 insertions(+) create mode 100644 tests/baselines/reference/declarationEmitReusesLambdaParameterNodes.js create mode 100644 tests/baselines/reference/declarationEmitReusesLambdaParameterNodes.symbols create mode 100644 tests/baselines/reference/declarationEmitReusesLambdaParameterNodes.types create mode 100644 tests/cases/compiler/declarationEmitReusesLambdaParameterNodes.ts diff --git a/tests/baselines/reference/declarationEmitReusesLambdaParameterNodes.js b/tests/baselines/reference/declarationEmitReusesLambdaParameterNodes.js new file mode 100644 index 0000000000000..7f3aa10fc2c0d --- /dev/null +++ b/tests/baselines/reference/declarationEmitReusesLambdaParameterNodes.js @@ -0,0 +1,27 @@ +//// [tests/cases/compiler/declarationEmitReusesLambdaParameterNodes.ts] //// + +//// [index.d.ts] +export type Whatever = {x: string, y: number}; +export type Props = Omit & Partial & T; + +//// [index.ts] +import { Props } from "react-select"; + +export const CustomSelect1 = (x: Props(x: A) => A; declare function a2(x: A): A; -declare var a3: (x: A_1) => A; +declare var a3: (x: A) => globalThis.A; declare function a4(x: A): globalThis.A; interface B { } -declare var b: (x: B_1) => B_1; +declare var b: (x: B) => B; declare function b2(x: B): B; diff --git a/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.types b/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.types index 018e04b6d7ee7..d2a8b2152650b 100644 --- a/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.types +++ b/tests/baselines/reference/declarationEmitTypeParameterNameInOuterScope.types @@ -5,8 +5,8 @@ class A { } >A : A var a = (x: A) => x; ->a : (x: A_1) => A_1 ->(x: A) => x : (x: A_1) => A_1 +>a : (x: A) => A +>(x: A) => x : (x: A) => A >x : A >x : A @@ -16,8 +16,8 @@ function a2(x: A) { return x } >x : A var a3 = (x: A) => new A(); ->a3 : (x: A_1) => A ->(x: A) => new A() : (x: A_1) => A +>a3 : (x: A) => globalThis.A +>(x: A) => new A() : (x: A) => globalThis.A >x : A >new A() : globalThis.A >A : typeof A @@ -32,8 +32,8 @@ function a4(x: A) { return new A() } interface B { } var b = (x: B) => x; ->b : (x: B_1) => B_1 ->(x: B) => x : (x: B_1) => B_1 +>b : (x: B) => B +>(x: B) => x : (x: B) => B >x : B >x : B diff --git a/tests/baselines/reference/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types b/tests/baselines/reference/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types index 12e603a310728..edf999b5eeebb 100644 --- a/tests/baselines/reference/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types +++ b/tests/baselines/reference/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.types @@ -50,8 +50,8 @@ export const updateIfChanged = (t: T) => { >key : K reduce>(u[key as keyof U] as Value, (v: Value) => { ->reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => (>>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>>) => Value>>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } ->reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K) => (>>(key: K) => (>>>(key: K) => (>>>>(key: K) => (>>>>>(key: K) => (>>>>>>(key: K) => (>>>>>>>(key: K) => (>>>>>>>>(key: K) => (>>>>>>>>>(key: K) => (>>>>>>>>>>(key: K) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } +>reduce>(u[key as keyof U] as Value, (v: Value) => { return update(Object.assign(Array.isArray(u) ? [] : {}, u, { [key]: v })); }) : (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => (>>>>>>>>>>>(key: K_11) => any & { map: (updater: (u: Value>>>>>>>>>>>) => Value>>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; } +>reduce : (u: U, update: (u: U) => T) => ((key: K) => (>(key: K_1) => (>>(key: K_2) => (>>>(key: K_3) => (>>>>(key: K_4) => (>>>>>(key: K_5) => (>>>>>>(key: K_6) => (>>>>>>>(key: K_7) => (>>>>>>>>(key: K_8) => (>>>>>>>>>(key: K_9) => (>>>>>>>>>>(key: K_10) => any & { map: (updater: (u: Value>>>>>>>>>>) => Value>>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>>) => Value>>>>>>>>>) => T; set: (newU: Value>>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>>) => Value>>>>>>>>) => T; set: (newU: Value>>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>>) => Value>>>>>>>) => T; set: (newU: Value>>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>>) => Value>>>>>>) => T; set: (newU: Value>>>>>>) => T; }) & { map: (updater: (u: Value>>>>>) => Value>>>>>) => T; set: (newU: Value>>>>>) => T; }) & { map: (updater: (u: Value>>>>) => Value>>>>) => T; set: (newU: Value>>>>) => T; }) & { map: (updater: (u: Value>>>) => Value>>>) => T; set: (newU: Value>>>) => T; }) & { map: (updater: (u: Value>>) => Value>>) => T; set: (newU: Value>>) => T; }) & { map: (updater: (u: Value>) => Value>) => T; set: (newU: Value>) => T; }) & { map: (updater: (u: Value) => Value) => T; set: (newU: Value) => T; }) & { map: (updater: (u: U) => U) => T; set: (newU: U) => T; } >u[key as keyof U] as Value : Value >u[key as keyof U] : U[keyof U] >u : U @@ -126,8 +126,8 @@ export const testRecFun = (parent: T) => { >child : U testRecFun({ ...parent, ...child }) ->testRecFun({ ...parent, ...child }) : { result: T & U; deeper: (child: U) => { result: T & U & U; deeper: (child: U) => { result: T & U & U & U; deeper: (child: U) => { result: T & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U & U & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U & U & U & U & U & U & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } ->testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U) => { result: T & U & U; deeper: (child: U) => { result: T & U & U & U; deeper: (child: U) => { result: T & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U & U & U & U & U; deeper: (child: U) => { result: T & U & U & U & U & U & U & U & U & U & U; deeper: (child: U) => any; }; }; }; }; }; }; }; }; }; }; } +>testRecFun({ ...parent, ...child }) : { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9 & U_10; deeper: (child: U_11) => any; }; }; }; }; }; }; }; }; }; }; } +>testRecFun : (parent: T) => { result: T; deeper: (child: U) => { result: T & U; deeper: (child: U_1) => { result: T & U & U_1; deeper: (child: U_2) => { result: T & U & U_1 & U_2; deeper: (child: U_3) => { result: T & U & U_1 & U_2 & U_3; deeper: (child: U_4) => { result: T & U & U_1 & U_2 & U_3 & U_4; deeper: (child: U_5) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5; deeper: (child: U_6) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6; deeper: (child: U_7) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7; deeper: (child: U_8) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8; deeper: (child: U_9) => { result: T & U & U_1 & U_2 & U_3 & U_4 & U_5 & U_6 & U_7 & U_8 & U_9; deeper: (child: U_10) => any; }; }; }; }; }; }; }; }; }; }; } >{ ...parent, ...child } : T & U >parent : T >child : U diff --git a/tests/baselines/reference/decoratorOnTypeAlias.types b/tests/baselines/reference/decoratorOnTypeAlias.types index 6938b10cb2e0a..06434b6386c90 100644 --- a/tests/baselines/reference/decoratorOnTypeAlias.types +++ b/tests/baselines/reference/decoratorOnTypeAlias.types @@ -6,7 +6,7 @@ declare function dec(target: T): T; >target : T @dec ->dec : (target: T_1) => T_1 +>dec : (target: T) => T type T = number; >T : number diff --git a/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.types b/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.types index 665d8c2e13756..938c886fdeae5 100644 --- a/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.types +++ b/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.types @@ -6,8 +6,8 @@ type Constructor = new (...args: any[]) => {}; >args : any[] const Mixin1 = (Base: C) => class extends Base { private _fooPrivate: {}; } ->Mixin1 : (Base: C_1) => { new (...args: any[]): (Anonymous class); prototype: Mixin1.(Anonymous class); } & C_1 ->(Base: C) => class extends Base { private _fooPrivate: {}; } : (Base: C_1) => { new (...args: any[]): (Anonymous class); prototype: Mixin1.(Anonymous class); } & C_1 +>Mixin1 : (Base: C) => { new (...args: any[]): (Anonymous class); prototype: Mixin1.(Anonymous class); } & C +>(Base: C) => class extends Base { private _fooPrivate: {}; } : (Base: C) => { new (...args: any[]): (Anonymous class); prototype: Mixin1.(Anonymous class); } & C >Base : C >class extends Base { private _fooPrivate: {}; } : { new (...args: any[]): (Anonymous class); prototype: Mixin1.(Anonymous class); } & C >Base : {} @@ -15,12 +15,12 @@ const Mixin1 = (Base: C) => class extends Base { private type FooConstructor = typeof Mixin1 extends (a: Constructor) => infer Cls ? Cls : never; >FooConstructor : { new (...args: any[]): Mixin1.(Anonymous class); prototype: Mixin1.(Anonymous class); } & Constructor ->Mixin1 : (Base: C_1) => { new (...args: any[]): (Anonymous class); prototype: Mixin1.(Anonymous class); } & C_1 +>Mixin1 : (Base: C) => { new (...args: any[]): (Anonymous class); prototype: Mixin1.(Anonymous class); } & C >a : Constructor const Mixin2 = (Base: C) => class extends Base {}; ->Mixin2 : .(Anonymous class); prototype: Mixin1.(Anonymous class); } & Constructor>(Base: C_1) => { new (...args: any[]): (Anonymous class); prototype: Mixin2.(Anonymous class); } & C_1 ->(Base: C) => class extends Base {} : .(Anonymous class); prototype: Mixin1.(Anonymous class); } & Constructor>(Base: C_1) => { new (...args: any[]): (Anonymous class); prototype: Mixin2.(Anonymous class); } & C_1 +>Mixin2 : .(Anonymous class); prototype: Mixin1.(Anonymous class); } & Constructor>(Base: C) => { new (...args: any[]): (Anonymous class); prototype: Mixin2.(Anonymous class); } & C +>(Base: C) => class extends Base {} : .(Anonymous class); prototype: Mixin1.(Anonymous class); } & Constructor>(Base: C) => { new (...args: any[]): (Anonymous class); prototype: Mixin2.(Anonymous class); } & C >Base : C >class extends Base {} : { new (...args: any[]): (Anonymous class); prototype: Mixin2.(Anonymous class); } & C >Base : Mixin1.(Anonymous class) @@ -28,8 +28,8 @@ const Mixin2 = (Base: C) => class extends Base {}; class C extends Mixin2(Mixin1(Object)) {} >C : C >Mixin2(Mixin1(Object)) : Mixin2<{ new (...args: any[]): Mixin1.(Anonymous class); prototype: Mixin1.(Anonymous class); } & ObjectConstructor>.(Anonymous class) & Mixin1.(Anonymous class) & Object ->Mixin2 : .(Anonymous class); prototype: Mixin1.(Anonymous class); } & Constructor>(Base: C_1) => { new (...args: any[]): (Anonymous class); prototype: Mixin2.(Anonymous class); } & C_1 +>Mixin2 : .(Anonymous class); prototype: Mixin1.(Anonymous class); } & Constructor>(Base: C) => { new (...args: any[]): (Anonymous class); prototype: Mixin2.(Anonymous class); } & C >Mixin1(Object) : { new (...args: any[]): Mixin1.(Anonymous class); prototype: Mixin1.(Anonymous class); } & ObjectConstructor ->Mixin1 : (Base: C_1) => { new (...args: any[]): (Anonymous class); prototype: Mixin1.(Anonymous class); } & C_1 +>Mixin1 : (Base: C) => { new (...args: any[]): (Anonymous class); prototype: Mixin1.(Anonymous class); } & C >Object : ObjectConstructor diff --git a/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.types b/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.types index f2b16d7f6a277..7cbe7c5f083ff 100644 --- a/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.types +++ b/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.types @@ -14,7 +14,7 @@ interface Array { >initialValue : T reduce(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, ->reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; (callbackfn: (previousValue: U_1, currentValue: T, currentIndex: number, array: T[]) => U_1, initialValue: U_1): U_1; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; (callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; } +>reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; (callbackfn: (previousValue: U_1, currentValue: T, currentIndex: number, array: T[]) => U_1, initialValue: U_1): U_1; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; (callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; } >callbackfn : (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U >previousValue : U >currentValue : T diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly2.types b/tests/baselines/reference/fixingTypeParametersRepeatedly2.types index d28e41bc02449..be32c7a69da8a 100644 --- a/tests/baselines/reference/fixingTypeParametersRepeatedly2.types +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly2.types @@ -40,7 +40,7 @@ declare function bar(x: T, func: (p: T) => T): T; >p : T declare function bar(x: T, func: (p: T) => T): T; ->bar : { (x: T_1, func: (p: T_1) => T_1): T_1; (x: T, func: (p: T) => T): T; } +>bar : { (x: T_1, func: (p: T_1) => T_1): T_1; (x: T, func: (p: T) => T): T; } >x : T >func : (p: T) => T >p : T diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly3.types b/tests/baselines/reference/fixingTypeParametersRepeatedly3.types index 17961996eb438..e84f62399fcc9 100644 --- a/tests/baselines/reference/fixingTypeParametersRepeatedly3.types +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly3.types @@ -40,7 +40,7 @@ declare function bar(x: T, func: (p: T) => T): T; >p : T declare function bar(x: T, func: (p: T) => T): T; ->bar : { (x: T_1, func: (p: T_1) => T_1): T_1; (x: T, func: (p: T) => T): T; } +>bar : { (x: T_1, func: (p: T_1) => T_1): T_1; (x: T, func: (p: T) => T): T; } >x : T >func : (p: T) => T >p : T diff --git a/tests/baselines/reference/functionLiterals.types b/tests/baselines/reference/functionLiterals.types index db5fcd843790e..17f64c39de6c8 100644 --- a/tests/baselines/reference/functionLiterals.types +++ b/tests/baselines/reference/functionLiterals.types @@ -196,7 +196,7 @@ var c2: { >x : T func4(s: T): string; ->func4 : { (x: T_1): number; (s: T): string; } +>func4 : { (x: T_1): number; (s: T): string; } >s : T func5: { diff --git a/tests/baselines/reference/functionOverloadErrors.types b/tests/baselines/reference/functionOverloadErrors.types index f30725307e382..fd5418cd10a51 100644 --- a/tests/baselines/reference/functionOverloadErrors.types +++ b/tests/baselines/reference/functionOverloadErrors.types @@ -130,7 +130,7 @@ function fn12>>(); >fn12 : { >>(): any; >(): any; } function fn12>(); ->fn12 : { >>(): any; >(): any; } +>fn12 : { >>(): any; >(): any; } function fn12() { } >fn12 : { >>(): any; >(): any; } @@ -241,7 +241,7 @@ function fn15>>(): T; >fn15 : { >>(): T; >(): T_1; } function fn15>(): T; ->fn15 : { >>(): T_1; >(): T; } +>fn15 : { >>(): T_1; >(): T; } function fn15() { >fn15 : { >>(): T; >(): T_1; } diff --git a/tests/baselines/reference/functionOverloadsOnGenericArity1.types b/tests/baselines/reference/functionOverloadsOnGenericArity1.types index 88ba3efd7d58b..1462d723c2e30 100644 --- a/tests/baselines/reference/functionOverloadsOnGenericArity1.types +++ b/tests/baselines/reference/functionOverloadsOnGenericArity1.types @@ -7,7 +7,7 @@ interface C { >f : { (): string; (): string; } f(): string; ->f : { (): string; (): string; } +>f : { (): string; (): string; } (): string; (): string; diff --git a/tests/baselines/reference/functionOverloadsOnGenericArity2.types b/tests/baselines/reference/functionOverloadsOnGenericArity2.types index b164491bee435..5a838f7564f52 100644 --- a/tests/baselines/reference/functionOverloadsOnGenericArity2.types +++ b/tests/baselines/reference/functionOverloadsOnGenericArity2.types @@ -11,6 +11,6 @@ interface I { >p : string then(p: string): Date; ->then : { (p: string): string; (p: string): string; (p: string): Date; } +>then : { (p: string): string; (p: string): string; (p: string): Date; } >p : string } diff --git a/tests/baselines/reference/functionOverloadsRecursiveGenericReturnType.types b/tests/baselines/reference/functionOverloadsRecursiveGenericReturnType.types index 4b8ed7f6134c6..d907313360a11 100644 --- a/tests/baselines/reference/functionOverloadsRecursiveGenericReturnType.types +++ b/tests/baselines/reference/functionOverloadsRecursiveGenericReturnType.types @@ -20,7 +20,7 @@ function Choice(args: T[]): A; >args : T[] function Choice(...v_args: T[]): A; ->Choice : { (args: T_1[]): A; (...v_args: T[]): A; } +>Choice : { (args: T_1[]): A; (...v_args: T[]): A; } >v_args : T[] function Choice(...v_args: any[]): A{ diff --git a/tests/baselines/reference/functionTypeArgumentArityErrors.types b/tests/baselines/reference/functionTypeArgumentArityErrors.types index c30f77ed4fedb..550e4b4220b09 100644 --- a/tests/baselines/reference/functionTypeArgumentArityErrors.types +++ b/tests/baselines/reference/functionTypeArgumentArityErrors.types @@ -6,7 +6,7 @@ declare function f1(): void; >f1 : { (): void; (): void; } declare function f1(): void; ->f1 : { (): void; (): void; } +>f1 : { (): void; (): void; } f1(); >f1() : void @@ -21,7 +21,7 @@ declare function f2(): void; >f2 : { (): void; (): void; } declare function f2(): void; ->f2 : { (): void; (): void; } +>f2 : { (): void; (): void; } f2(); >f2() : void diff --git a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.types b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.types index a1f14fcec119c..e34ed16c8ab6e 100644 --- a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.types +++ b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.types @@ -71,7 +71,7 @@ module m3 { >x : T then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; ->then : { (cb: (x: T) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; } +>then : { (cb: (x: T) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; } >cb : (x: T) => Promise >x : T >error : (error: any) => Promise @@ -106,7 +106,7 @@ module m4 { >x : T then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; ->then : { (cb: (x: T) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; } +>then : { (cb: (x: T) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; } >cb : (x: T) => Promise >x : T >error : (error: any) => Promise @@ -145,14 +145,14 @@ module m5 { >x : T then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; ->then : { (cb: (x: T) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => U_3, progress?: (preservation: any) => void): Promise; } +>then : { (cb: (x: T) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => U_2, progress?: (preservation: any) => void): Promise; } >cb : (x: T) => Promise >x : T >error : (error: any) => Promise >error : any then(cb: (x: T) => Promise, error?: (error: any) => U, progress?: (preservation: any) => void): Promise; ->then : { (cb: (x: T) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => U, progress?: (preservation: any) => void): Promise; } +>then : { (cb: (x: T) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => U, progress?: (preservation: any) => void): Promise; } >cb : (x: T) => Promise >x : T >error : (error: any) => U @@ -193,7 +193,7 @@ module m6 { >x : T then(cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; ->then : { (cb: (x: T) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; } +>then : { (cb: (x: T) => Promise): Promise; (cb: (x: T) => Promise, error?: (error: any) => Promise): Promise; } >cb : (x: T) => Promise >x : T >error : (error: any) => Promise diff --git a/tests/baselines/reference/genericClassesRedeclaration.types b/tests/baselines/reference/genericClassesRedeclaration.types index e8b5a92a5f619..a2ee0056dfecb 100644 --- a/tests/baselines/reference/genericClassesRedeclaration.types +++ b/tests/baselines/reference/genericClassesRedeclaration.types @@ -168,7 +168,7 @@ declare module TypeScript { >s : string } function createIntrinsicsObject(): IIndexable; ->createIntrinsicsObject : { (): IIndexable; (): IIndexable; } +>createIntrinsicsObject : { (): IIndexable; (): IIndexable; } interface IHashTable { getAllKeys(): string[]; diff --git a/tests/baselines/reference/genericCombinators2.types b/tests/baselines/reference/genericCombinators2.types index 52c8059977be3..4001adb49c1de 100644 --- a/tests/baselines/reference/genericCombinators2.types +++ b/tests/baselines/reference/genericCombinators2.types @@ -25,7 +25,7 @@ interface Combinators { >y : U map(c: Collection, f: (x: T, y: U) => V): Collection; ->map : { (c: Collection, f: (x: T_1, y: U_1) => any): Collection; (c: Collection, f: (x: T, y: U) => V): Collection; } +>map : { (c: Collection, f: (x: T_1, y: U_1) => any): Collection; (c: Collection, f: (x: T, y: U) => V): Collection; } >c : Collection >f : (x: T, y: U) => V >x : T diff --git a/tests/baselines/reference/genericFunctionInference1.types b/tests/baselines/reference/genericFunctionInference1.types index fc0b360cd8c38..f51ff23ee1cfb 100644 --- a/tests/baselines/reference/genericFunctionInference1.types +++ b/tests/baselines/reference/genericFunctionInference1.types @@ -8,7 +8,7 @@ declare function pipe(ab: (...args: A) => B): (...args: A) = >args : A declare function pipe(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; ->pipe : { (ab: (...args: A_1) => B_1): (...args: A_1) => B_1; (ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; (ab: (...args: A_3) => B_3, bc: (b: B_3) => C_1, cd: (c: C_1) => D): (...args: A_3) => D; } +>pipe : { (ab: (...args: A_1) => B_1): (...args: A_1) => B_1; (ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; (ab: (...args: A_2) => B_2, bc: (b: B_2) => C_1, cd: (c: C_1) => D): (...args: A_2) => D; } >ab : (...args: A) => B >args : A >bc : (b: B) => C @@ -16,7 +16,7 @@ declare function pipe(ab: (...args: A) => B, bc: (b: B) = >args : A declare function pipe(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; ->pipe : { (ab: (...args: A_1) => B_1): (...args: A_1) => B_1; (ab: (...args: A_2) => B_2, bc: (b: B_2) => C_1): (...args: A_2) => C_1; (ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; } +>pipe : { (ab: (...args: A_1) => B_1): (...args: A_1) => B_1; (ab: (...args: A_2) => B_2, bc: (b: B_2) => C_1): (...args: A_2) => C_1; (ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; } >ab : (...args: A) => B >args : A >bc : (b: B) => C @@ -167,7 +167,7 @@ const g00: (x: T) => T[] = pipe(list); >list : (a: T) => T[] const g01: (x: T) => { value: T[] } = pipe(list, box); ->g01 : (x: T) => { value: T[]; } +>g01 : (x: T) => { value: T[];} >x : T >value : T[] >pipe(list, box) : (a: T) => { value: T[]; } @@ -176,7 +176,7 @@ const g01: (x: T) => { value: T[] } = pipe(list, box); >box : (x: V) => { value: V; } const g02: (x: T) => { value: T }[] = pipe(box, list); ->g02 : (x: T) => { value: T; }[] +>g02 : (x: T) => { value: T;}[] >x : T >value : T >pipe(box, list) : (x: T) => { value: T; }[] @@ -185,7 +185,7 @@ const g02: (x: T) => { value: T }[] = pipe(box, list); >list : (a: T) => T[] const g03: (x: T) => { value: T[] } = pipe(x => list(x), box); ->g03 : (x: T) => { value: T[]; } +>g03 : (x: T) => { value: T[];} >x : T >value : T[] >pipe(x => list(x), box) : (x: T) => { value: T[]; } @@ -198,7 +198,7 @@ const g03: (x: T) => { value: T[] } = pipe(x => list(x), box); >box : (x: V) => { value: V; } const g04: (x: T) => { value: T[] } = pipe(list, x => box(x)); ->g04 : (x: T) => { value: T[]; } +>g04 : (x: T) => { value: T[];} >x : T >value : T[] >pipe(list, x => box(x)) : (a: T) => { value: T[]; } @@ -211,7 +211,7 @@ const g04: (x: T) => { value: T[] } = pipe(list, x => box(x)); >x : T[] const g05: (x: T) => { value: T[] } = pipe(x => list(x), x => box(x)) ->g05 : (x: T) => { value: T[]; } +>g05 : (x: T) => { value: T[];} >x : T >value : T[] >pipe(x => list(x), x => box(x)) : (x: T) => { value: T[]; } @@ -228,7 +228,7 @@ const g05: (x: T) => { value: T[] } = pipe(x => list(x), x => box(x)) >x : T[] const g06: (x: T) => { value: T[] } = pipe(list, pipe(box)); ->g06 : (x: T) => { value: T[]; } +>g06 : (x: T) => { value: T[];} >x : T >value : T[] >pipe(list, pipe(box)) : (a: T) => { value: T[]; } @@ -239,7 +239,7 @@ const g06: (x: T) => { value: T[] } = pipe(list, pipe(box)); >box : (x: V) => { value: V; } const g07: (x: T) => { value: T[] } = pipe(x => list(x), pipe(box)); ->g07 : (x: T) => { value: T[]; } +>g07 : (x: T) => { value: T[];} >x : T >value : T[] >pipe(x => list(x), pipe(box)) : (x: T) => { value: T[]; } @@ -254,7 +254,7 @@ const g07: (x: T) => { value: T[] } = pipe(x => list(x), pipe(box)); >box : (x: V) => { value: V; } const g08: (x: T) => { value: T[] } = pipe(x => list(x), pipe(x => box(x))); ->g08 : (x: T) => { value: T[]; } +>g08 : (x: T) => { value: T[];} >x : T >value : T[] >pipe(x => list(x), pipe(x => box(x))) : (x: T) => { value: T[]; } diff --git a/tests/baselines/reference/genericFunctionParameters.types b/tests/baselines/reference/genericFunctionParameters.types index 769eb8dfc73b6..e2549fac1199b 100644 --- a/tests/baselines/reference/genericFunctionParameters.types +++ b/tests/baselines/reference/genericFunctionParameters.types @@ -44,7 +44,7 @@ let x3 = f3(x => x); // Array declare const s: (go: (ops: { init(): S; }) => R) => R; >s : (go: (ops: { init(): S; }) => R) => R ->go : (ops: { init(): S; }) => R +>go : (ops: { init(): S;}) => R >ops : { init(): S; } >init : () => S diff --git a/tests/baselines/reference/genericOverloadSignatures.types b/tests/baselines/reference/genericOverloadSignatures.types index 2de7c3b8277a0..ba14576f15e11 100644 --- a/tests/baselines/reference/genericOverloadSignatures.types +++ b/tests/baselines/reference/genericOverloadSignatures.types @@ -14,7 +14,7 @@ function f(a: T); >a : T function f(a: T); ->f : { (a: T_1): any; (a: T): any; } +>f : { (a: T_1): any; (a: T): any; } >a : T function f(a) { } @@ -27,7 +27,7 @@ interface I2 { >x : T f(x: T): string; ->f : { (x: T_1): number; (x: T): string; } +>f : { (x: T_1): number; (x: T): string; } >x : T } diff --git a/tests/baselines/reference/genericSpecializationToTypeLiteral1.types b/tests/baselines/reference/genericSpecializationToTypeLiteral1.types index f3a3711f628a0..29aef5e1af890 100644 --- a/tests/baselines/reference/genericSpecializationToTypeLiteral1.types +++ b/tests/baselines/reference/genericSpecializationToTypeLiteral1.types @@ -12,7 +12,7 @@ interface IEnumerable { >index : number zip(second: T[], resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable; ->zip : { (second: IEnumerable, resultSelector: (first: T, second: T, index: number) => TResult_1): IEnumerable; (second: T[], resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable; (...params: any[]): IEnumerable; } +>zip : { (second: IEnumerable, resultSelector: (first: T, second: T, index: number) => TResult_1): IEnumerable; (second: T[], resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable; (...params: any[]): IEnumerable; } >second : T[] >resultSelector : (first: T, second: T, index: number) => TResult >first : T @@ -20,7 +20,7 @@ interface IEnumerable { >index : number zip(...params: any[]): IEnumerable; // last one is selector ->zip : { (second: IEnumerable, resultSelector: (first: T, second: T, index: number) => TResult_1): IEnumerable; (second: T[], resultSelector: (first: T, second: T, index: number) => TResult_2): IEnumerable; (...params: any[]): IEnumerable; } +>zip : { (second: IEnumerable, resultSelector: (first: T, second: T, index: number) => TResult_1): IEnumerable; (second: T[], resultSelector: (first: T, second: T, index: number) => TResult_2): IEnumerable; (...params: any[]): IEnumerable; } >params : any[] merge(...params: IEnumerable[]): IEnumerable; @@ -28,7 +28,7 @@ interface IEnumerable { >params : IEnumerable[] merge(...params: T[][]): IEnumerable; ->merge : { (...params: IEnumerable[]): IEnumerable; (...params: T[][]): IEnumerable; } +>merge : { (...params: IEnumerable[]): IEnumerable; (...params: T[][]): IEnumerable; } >params : T[][] @@ -60,7 +60,7 @@ interface IEnumerable { >second : T[] sequenceEqual(second: T[], compareSelector: (element: T) => TCompare): boolean; ->sequenceEqual : { (second: IEnumerable): boolean; (second: IEnumerable, compareSelector: (element: T) => TCompare_1): boolean; (second: T[]): boolean; (second: T[], compareSelector: (element: T) => TCompare): boolean; } +>sequenceEqual : { (second: IEnumerable): boolean; (second: IEnumerable, compareSelector: (element: T) => TCompare_1): boolean; (second: T[]): boolean; (second: T[], compareSelector: (element: T) => TCompare): boolean; } >second : T[] >compareSelector : (element: T) => TCompare >element : T @@ -71,14 +71,14 @@ interface IEnumerable { >element : T toDictionary(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary; ->toDictionary : { (keySelector: (element: T) => TKey_1): IDictionary; (keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary; (keySelector: (element: T) => TKey_3, elementSelector: (element: T) => TValue_1, compareSelector: (key: TKey_3) => TCompare): IDictionary; } +>toDictionary : { (keySelector: (element: T) => TKey_1): IDictionary; (keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary; (keySelector: (element: T) => TKey_2, elementSelector: (element: T) => TValue_1, compareSelector: (key: TKey_2) => TCompare): IDictionary; } >keySelector : (element: T) => TKey >element : T >elementSelector : (element: T) => TValue >element : T toDictionary(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): IDictionary; ->toDictionary : { (keySelector: (element: T) => TKey_1): IDictionary; (keySelector: (element: T) => TKey_2, elementSelector: (element: T) => TValue_1): IDictionary; (keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): IDictionary; } +>toDictionary : { (keySelector: (element: T) => TKey_1): IDictionary; (keySelector: (element: T) => TKey_2, elementSelector: (element: T) => TValue_1): IDictionary; (keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): IDictionary; } >keySelector : (element: T) => TKey >element : T >elementSelector : (element: T) => TValue diff --git a/tests/baselines/reference/grammarAmbiguities.types b/tests/baselines/reference/grammarAmbiguities.types index 88ecd7d422b35..e4f63fedbb0b5 100644 --- a/tests/baselines/reference/grammarAmbiguities.types +++ b/tests/baselines/reference/grammarAmbiguities.types @@ -19,14 +19,14 @@ f(g(7)); >f(g(7)) : any >f : (n: any) => any >g(7) : any ->g : (x: any) => any +>g : (x: any) => any >7 : 7 f(g < A, B > 7); // Should error >f(g < A, B > 7) : any >f : (n: any) => any >g < A : boolean ->g : (x: any) => any +>g : (x: any) => any >A : any >B > 7 : boolean >B : any @@ -36,7 +36,7 @@ f(g < A, B > +(7)); // Should error >f(g < A, B > +(7)) : any >f : (n: any) => any >g < A : boolean ->g : (x: any) => any +>g : (x: any) => any >A : any >B > +(7) : boolean >B : any diff --git a/tests/baselines/reference/inferTypes1.types b/tests/baselines/reference/inferTypes1.types index f3b34af033753..3ce2bf2dd5011 100644 --- a/tests/baselines/reference/inferTypes1.types +++ b/tests/baselines/reference/inferTypes1.types @@ -480,7 +480,7 @@ const result = invoker('test', true)({ test: (a: boolean) => 123 }) >result : number >invoker('test', true)({ test: (a: boolean) => 123 }) : number >invoker('test', true) : any>>(obj: T) => ReturnType ->invoker : (key: K, ...args: A_1) => any>>(obj: T) => ReturnType +>invoker : (key: K, ...args: A) => any>>(obj: T) => ReturnType >'test' : "test" >true : true >{ test: (a: boolean) => 123 } : { test: (a: boolean) => number; } diff --git a/tests/baselines/reference/inferenceDoesNotAddUndefinedOrNull.types b/tests/baselines/reference/inferenceDoesNotAddUndefinedOrNull.types index 1e2a96b305ede..fb0cadb30bedc 100644 --- a/tests/baselines/reference/inferenceDoesNotAddUndefinedOrNull.types +++ b/tests/baselines/reference/inferenceDoesNotAddUndefinedOrNull.types @@ -17,7 +17,7 @@ declare function toArray(value: T | T[]): T[]; >value : T | T[] declare function toArray(value: T | readonly T[]): readonly T[]; ->toArray : { (value: T_1 | T_1[]): T_1[]; (value: T | readonly T[]): readonly T[]; } +>toArray : { (value: T_1 | T_1[]): T_1[]; (value: T | readonly T[]): readonly T[]; } >value : T | readonly T[] function flatMapChildren(node: Node, cb: (child: Node) => readonly T[] | T | undefined): readonly T[] { diff --git a/tests/baselines/reference/infinitelyExpandingTypes5.types b/tests/baselines/reference/infinitelyExpandingTypes5.types index 9ba91ec0090eb..be550893143fe 100644 --- a/tests/baselines/reference/infinitelyExpandingTypes5.types +++ b/tests/baselines/reference/infinitelyExpandingTypes5.types @@ -19,7 +19,7 @@ function from(array: T[]): Query; >array : T[] function from(enumerator: Enumerator): Query; ->from : { (array: T_1[]): Query; (enumerator: Enumerator): Query; } +>from : { (array: T_1[]): Query; (enumerator: Enumerator): Query; } >enumerator : Enumerator function from(arg: any): any { diff --git a/tests/baselines/reference/instantiationExpressions.types b/tests/baselines/reference/instantiationExpressions.types index 11410cfb0f22b..33c9224acc42b 100644 --- a/tests/baselines/reference/instantiationExpressions.types +++ b/tests/baselines/reference/instantiationExpressions.types @@ -6,12 +6,12 @@ declare function fx(x: T): T; >x : T declare function fx(x: T, n: number): T; ->fx : { (x: T_1): T_1; (x: T, n: number): T; (t: [T_3, U]): [T_3, U]; } +>fx : { (x: T_1): T_1; (x: T, n: number): T; (t: [T_2, U]): [T_2, U]; } >x : T >n : number declare function fx(t: [T, U]): [T, U]; ->fx : { (x: T_1): T_1; (x: T_2, n: number): T_2; (t: [T, U]): [T, U]; } +>fx : { (x: T_1): T_1; (x: T_2, n: number): T_2; (t: [T, U]): [T, U]; } >t : [T, U] function f1() { @@ -419,16 +419,16 @@ function f37(f: ((a: T) => T) | (new (a: string, b: number) => string[])) { } function f38(x: A) => A) | ((x: B) => B[]), U>(f: T | U | ((x: C) => C[][])) { ->f38 : (x: A_1) => A_1) | ((x: B) => B[]), U>(f: T | U | ((x: C_1) => C_1[][])) => void +>f38 : (x: A) => A) | ((x: B) => B[]), U>(f: T | U | ((x: C) => C[][])) => void >x : A >x : B ->f : T | U | ((x: C_1) => C_1[][]) +>f : T | U | ((x: C) => C[][]) >x : C let fs = f; // U | ((x: string) => string) | ((x: string) => string[]) | ((x: string) => string[][]) >fs : U | ((x: string) => string) | ((x: string) => string[]) | ((x: string) => string[][]) >f : U | ((x: string) => string) | ((x: string) => string[]) | ((x: string) => string[][]) ->f : T | U | ((x: C_1) => C_1[][]) +>f : T | U | ((x: C) => C[][]) } function makeBox(value: T) { @@ -459,7 +459,7 @@ type A = InstanceType>; // U[] >Array : ArrayConstructor declare const g1: { ->g1 : { (a: T): { a: T; }; new (b: U): { b: U; }; } +>g1 : { (a: T): { a: T;}; new (b: U): { b: U;}; } (a: T): { a: T }; >a : T diff --git a/tests/baselines/reference/intersectionTypeInference1.types b/tests/baselines/reference/intersectionTypeInference1.types index 216e5c238e689..096be34a8b5e8 100644 --- a/tests/baselines/reference/intersectionTypeInference1.types +++ b/tests/baselines/reference/intersectionTypeInference1.types @@ -19,8 +19,8 @@ const parameterFn = (props:{store:string}) => alert(props.store) >store : string const brokenFunction = (f: (p: {dispatch: number} & OwnProps) => void) => (o: OwnProps) => o ->brokenFunction : (f: (p: { dispatch: number; } & OwnProps) => void) => (o: OwnProps) => OwnProps ->(f: (p: {dispatch: number} & OwnProps) => void) => (o: OwnProps) => o : (f: (p: { dispatch: number; } & OwnProps) => void) => (o: OwnProps) => OwnProps +>brokenFunction : (f: (p: { dispatch: number;} & OwnProps) => void) => (o: OwnProps) => OwnProps +>(f: (p: {dispatch: number} & OwnProps) => void) => (o: OwnProps) => o : (f: (p: { dispatch: number;} & OwnProps) => void) => (o: OwnProps) => OwnProps >f : (p: { dispatch: number;} & OwnProps) => void >p : { dispatch: number; } & OwnProps >dispatch : number diff --git a/tests/baselines/reference/ipromise2.types b/tests/baselines/reference/ipromise2.types index ff92db3c4eddf..9a3eaf5bad288 100644 --- a/tests/baselines/reference/ipromise2.types +++ b/tests/baselines/reference/ipromise2.types @@ -15,7 +15,7 @@ declare module Windows.Foundation { >Foundation : any then(success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise; (success?: (value: T) => U_2, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): IPromise; } >success : (value: T) => IPromise >value : T >error : (error: any) => U @@ -26,7 +26,7 @@ declare module Windows.Foundation { >Foundation : any then(success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void ): Windows.Foundation.IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): Windows.Foundation.IPromise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): Windows.Foundation.IPromise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): IPromise; } >success : (value: T) => U >value : T >error : (error: any) => IPromise @@ -37,7 +37,7 @@ declare module Windows.Foundation { >Foundation : any then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise; } >success : (value: T) => U >value : T >error : (error: any) => U diff --git a/tests/baselines/reference/ipromise3.types b/tests/baselines/reference/ipromise3.types index 9e89b5f24fb03..1971000bd01ff 100644 --- a/tests/baselines/reference/ipromise3.types +++ b/tests/baselines/reference/ipromise3.types @@ -12,7 +12,7 @@ interface IPromise3 { >progress : any then(success?: (value: T) => IPromise3, error?: (error: any) => U, progress?: (progress: any) => void ): IPromise3; ->then : { (success?: (value: T) => IPromise3, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => IPromise3, error?: (error: any) => U, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U_3, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): IPromise3; } +>then : { (success?: (value: T) => IPromise3, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => IPromise3, error?: (error: any) => U, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U_2, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): IPromise3; } >success : (value: T) => IPromise3 >value : T >error : (error: any) => U @@ -21,7 +21,7 @@ interface IPromise3 { >progress : any then(success?: (value: T) => U, error?: (error: any) => IPromise3, progress?: (progress: any) => void ): IPromise3; ->then : { (success?: (value: T) => IPromise3, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => IPromise3, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): IPromise3; } +>then : { (success?: (value: T) => IPromise3, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => IPromise3, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): IPromise3; } >success : (value: T) => U >value : T >error : (error: any) => IPromise3 @@ -30,7 +30,7 @@ interface IPromise3 { >progress : any then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void ): IPromise3; ->then : { (success?: (value: T) => IPromise3, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => IPromise3, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U_3, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise3; } +>then : { (success?: (value: T) => IPromise3, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => IPromise3, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U_3, error?: (error: any) => IPromise3, progress?: (progress: any) => void): IPromise3; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise3; } >success : (value: T) => U >value : T >error : (error: any) => U diff --git a/tests/baselines/reference/ipromise4.types b/tests/baselines/reference/ipromise4.types index 332c250b6e7fd..2dfd786588dbb 100644 --- a/tests/baselines/reference/ipromise4.types +++ b/tests/baselines/reference/ipromise4.types @@ -15,7 +15,7 @@ declare module Windows.Foundation { >Foundation : any then(success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise; (success?: (value: T) => U_2, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): IPromise; } >success : (value: T) => IPromise >value : T >error : (error: any) => U @@ -26,7 +26,7 @@ declare module Windows.Foundation { >Foundation : any then(success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void ): Windows.Foundation.IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): Windows.Foundation.IPromise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): Windows.Foundation.IPromise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): IPromise; } >success : (value: T) => U >value : T >error : (error: any) => IPromise @@ -37,7 +37,7 @@ declare module Windows.Foundation { >Foundation : any then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise; } >success : (value: T) => U >value : T >error : (error: any) => U diff --git a/tests/baselines/reference/isDeclarationVisibleNodeKinds.types b/tests/baselines/reference/isDeclarationVisibleNodeKinds.types index 38da8a8daca45..9581f9d403a8d 100644 --- a/tests/baselines/reference/isDeclarationVisibleNodeKinds.types +++ b/tests/baselines/reference/isDeclarationVisibleNodeKinds.types @@ -6,7 +6,7 @@ module schema { >schema : typeof schema export function createValidator1(schema: any): (data: T) => T { ->createValidator1 : (schema: any) => (data: T_1) => T_1 +>createValidator1 : (schema: any) => (data: T) => T >schema : any >data : T @@ -20,7 +20,7 @@ module schema { >schema : typeof schema export function createValidator2(schema: any): new (data: T) => T { ->createValidator2 : (schema: any) => new (data: T_1) => T_1 +>createValidator2 : (schema: any) => new (data: T) => T >schema : any >data : T @@ -34,7 +34,7 @@ module schema { >schema : typeof schema export function createValidator3(schema: any): number | { new (data: T): T; } { ->createValidator3 : (schema: any) => number | (new (data: T_1) => T_1) +>createValidator3 : (schema: any) => number | (new (data: T) => T) >schema : any >data : T @@ -48,7 +48,7 @@ module schema { >schema : typeof schema export function createValidator4(schema: any): { new (data: T): T; }[] { ->createValidator4 : (schema: any) => (new (data: T_1) => T_1)[] +>createValidator4 : (schema: any) => (new (data: T) => T)[] >schema : any >data : T @@ -63,7 +63,7 @@ module schema { >schema : typeof schema export function createValidator5(schema: any): { new (data: T): T } { ->createValidator5 : (schema: any) => new (data: T_1) => T_1 +>createValidator5 : (schema: any) => new (data: T) => T >schema : any >data : T @@ -77,7 +77,7 @@ module schema { >schema : typeof schema export function createValidator6(schema: any): [ new (data: T) => T, number] { ->createValidator6 : (schema: any) => [new (data: T_1) => T_1, number] +>createValidator6 : (schema: any) => [new (data: T) => T, number] >schema : any >data : T @@ -91,7 +91,7 @@ module schema { >schema : typeof schema export function createValidator7(schema: any): (new (data: T)=>T )[] { ->createValidator7 : (schema: any) => (new (data: T_1) => T_1)[] +>createValidator7 : (schema: any) => (new (data: T) => T)[] >schema : any >data : T @@ -105,7 +105,7 @@ module schema { >schema : typeof schema export function createValidator8(schema: any): Array<{ (data: T) : T}> { ->createValidator8 : (schema: any) => ((data: T_1) => T_1)[] +>createValidator8 : (schema: any) => ((data: T) => T)[] >schema : any >data : T @@ -122,7 +122,7 @@ module schema { >T : T get createValidator9(): (data: T) => T { ->createValidator9 : (data: T_1) => T_1 +>createValidator9 : (data: T) => T >data : T return undefined; @@ -130,8 +130,8 @@ module schema { } set createValidator10(v: (data: T) => T) { ->createValidator10 : (data: T_1) => T_1 ->v : (data: T_1) => T_1 +>createValidator10 : (data: T) => T +>v : (data: T) => T >data : T } } diff --git a/tests/baselines/reference/jsDeclarationsClasses.js b/tests/baselines/reference/jsDeclarationsClasses.js index d2df8ba6729a1..9444df18fd335 100644 --- a/tests/baselines/reference/jsDeclarationsClasses.js +++ b/tests/baselines/reference/jsDeclarationsClasses.js @@ -541,7 +541,7 @@ export class F { * @param {A} a * @param {B} b */ - static create(a: A_1, b: B_1): F; + static create(a: A, b: B): F; /** * @param {T} a * @param {U} b diff --git a/tests/baselines/reference/jsDeclarationsInterfaces.js b/tests/baselines/reference/jsDeclarationsInterfaces.js index f327cfee537f2..707b8eac1aee9 100644 --- a/tests/baselines/reference/jsDeclarationsInterfaces.js +++ b/tests/baselines/reference/jsDeclarationsInterfaces.js @@ -134,19 +134,19 @@ export interface A { export interface B { cat: string; } -export interface C { +export interface C { new (): string; - new (x: T_1): U_1; - new (x: Q_4): T_1 & Q_4; + new (x: T): U; + new (x: Q_3): T & Q_3; (): number; - (x: T_1): U_1; - (x: Q_3): T_1 & Q_3; - field: T_1 & U_1; - optionalField?: T_1; - readonly readonlyField: T_1 & U_1; - readonly readonlyOptionalField?: U_1; - method(): number; - method(a: T_1 & Q_2): Q_2 & number; + (x: T): U; + (x: Q_2): T & Q_2; + field: T & U; + optionalField?: T; + readonly readonlyField: T & U; + readonly readonlyOptionalField?: U; + method(): number; + method(a: T & Q_1): Q_1 & number; method(a?: number): number; method(...args: any[]): number; optMethod?(): number; @@ -161,11 +161,11 @@ export interface K extends I, J { export interface L extends K { y: string; } -export interface M { - field: T_1; +export interface M { + field: T; } -export interface N extends M { - other: U_1; +export interface N extends M { + other: U; } export interface O { [idx: string]: string; diff --git a/tests/baselines/reference/jsDeclarationsInterfaces.types b/tests/baselines/reference/jsDeclarationsInterfaces.types index 31be3a1660dda..2f93c0f6aa320 100644 --- a/tests/baselines/reference/jsDeclarationsInterfaces.types +++ b/tests/baselines/reference/jsDeclarationsInterfaces.types @@ -42,15 +42,15 @@ export interface C { >method : { (): number; (a: T & Q_1): Q_1 & number; (a?: number): number; (...args: any[]): number; } method(a: T & Q): Q & number; ->method : { (): number; (a: T & Q): Q & number; (a?: number): number; (...args: any[]): number; } +>method : { (): number; (a: T & Q): Q & number; (a?: number): number; (...args: any[]): number; } >a : T & Q method(a?: number): number; ->method : { (): number; (a: T & Q_2): Q_2 & number; (a?: number): number; (...args: any[]): number; } +>method : { (): number; (a: T & Q_1): Q_1 & number; (a?: number): number; (...args: any[]): number; } >a : number method(...args: any[]): number; ->method : { (): number; (a: T & Q_2): Q_2 & number; (a?: number): number; (...args: any[]): number; } +>method : { (): number; (a: T & Q_1): Q_1 & number; (a?: number): number; (...args: any[]): number; } >args : any[] optMethod?(): number; diff --git a/tests/baselines/reference/jsxExcessPropsAndAssignability.types b/tests/baselines/reference/jsxExcessPropsAndAssignability.types index 1469e837a8ed6..f1e19342f97ee 100644 --- a/tests/baselines/reference/jsxExcessPropsAndAssignability.types +++ b/tests/baselines/reference/jsxExcessPropsAndAssignability.types @@ -7,8 +7,8 @@ import * as React from 'react'; >React : typeof React const myHoc = ( ->myHoc : (ComposedComponent: React.ComponentClass) => void ->( ComposedComponent: React.ComponentClass,) => { type WrapperComponentProps = ComposedComponentProps & { myProp: string }; const WrapperComponent: React.ComponentClass = null as any; const props: ComposedComponentProps = null as any; ; ;} : (ComposedComponent: React.ComponentClass) => void +>myHoc : (ComposedComponent: React.ComponentClass) => void +>( ComposedComponent: React.ComponentClass,) => { type WrapperComponentProps = ComposedComponentProps & { myProp: string }; const WrapperComponent: React.ComponentClass = null as any; const props: ComposedComponentProps = null as any; ; ;} : (ComposedComponent: React.ComponentClass) => void ComposedComponent: React.ComponentClass, >ComposedComponent : React.ComponentClass diff --git a/tests/baselines/reference/jsxGenericComponentWithSpreadingResultOfGenericFunction.types b/tests/baselines/reference/jsxGenericComponentWithSpreadingResultOfGenericFunction.types index 3ee7e5d05f785..37434455083d0 100644 --- a/tests/baselines/reference/jsxGenericComponentWithSpreadingResultOfGenericFunction.types +++ b/tests/baselines/reference/jsxGenericComponentWithSpreadingResultOfGenericFunction.types @@ -11,7 +11,7 @@ declare function omit(names: readonly K[], obj: T): Omitobj : T declare function omit(names: readonly K[]): (obj: T) => Omit; ->omit : { (names: readonly K_1[], obj: T): Omit; (names: readonly K[]): (obj: T_1) => Omit; } +>omit : { (names: readonly K_1[], obj: T): Omit; (names: readonly K[]): (obj: T_1) => Omit; } >names : readonly K[] >obj : T diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types index 21a20a2e4ff51..d1aca03181660 100644 --- a/tests/baselines/reference/keyofAndIndexedAccess.types +++ b/tests/baselines/reference/keyofAndIndexedAccess.types @@ -765,8 +765,8 @@ function f60(source: T, target: T) { } function f70(func: (k1: keyof (T | U), k2: keyof (T & U)) => void) { ->f70 : (func: (k1: keyof T & keyof U, k2: keyof T | keyof U) => void) => void ->func : (k1: keyof T & keyof U, k2: keyof T | keyof U) => void +>f70 : (func: (k1: keyof (T | U), k2: keyof (T & U)) => void) => void +>func : (k1: keyof (T | U), k2: keyof (T & U)) => void >k1 : keyof T & keyof U >k2 : keyof T | keyof U @@ -1406,13 +1406,13 @@ function path(obj: T, key1: K1): T[K1]; >key1 : K1 function path(obj: T, key1: K1, key2: K2): T[K1][K2]; ->path : { (obj: T_1, key1: K1_1): T_1[K1_1]; (obj: T, key1: K1, key2: K2): T[K1][K2]; (obj: T_3, key1: K1_3, key2: K2_1, key3: K3): T_3[K1_3][K2_1][K3]; (obj: any, ...keys: (string | number)[]): any; } +>path : { (obj: T_1, key1: K1_1): T_1[K1_1]; (obj: T, key1: K1, key2: K2): T[K1][K2]; (obj: T_2, key1: K1_2, key2: K2_1, key3: K3): T_2[K1_2][K2_1][K3]; (obj: any, ...keys: (string | number)[]): any; } >obj : T >key1 : K1 >key2 : K2 function path(obj: T, key1: K1, key2: K2, key3: K3): T[K1][K2][K3]; ->path : { (obj: T_1, key1: K1_1): T_1[K1_1]; (obj: T_2, key1: K1_2, key2: K2_1): T_2[K1_2][K2_1]; (obj: T, key1: K1, key2: K2, key3: K3): T[K1][K2][K3]; (obj: any, ...keys: (string | number)[]): any; } +>path : { (obj: T_1, key1: K1_1): T_1[K1_1]; (obj: T_2, key1: K1_2, key2: K2_1): T_2[K1_2][K2_1]; (obj: T, key1: K1, key2: K2, key3: K3): T[K1][K2][K3]; (obj: any, ...keys: (string | number)[]): any; } >obj : T >key1 : K1 >key2 : K2 diff --git a/tests/baselines/reference/methodSignaturesWithOverloads.types b/tests/baselines/reference/methodSignaturesWithOverloads.types index 90f0eaead1582..c216519d3a4bf 100644 --- a/tests/baselines/reference/methodSignaturesWithOverloads.types +++ b/tests/baselines/reference/methodSignaturesWithOverloads.types @@ -34,7 +34,7 @@ var c2: { >x : T func4? (s: T): string; // error, mismatched optionality ->func4 : { (x: T_1): number; (s: T): string; } +>func4 : { (x: T_1): number; (s: T): string; } >s : T func5?: { diff --git a/tests/baselines/reference/methodSignaturesWithOverloads2.types b/tests/baselines/reference/methodSignaturesWithOverloads2.types index 5db07de7f1412..2dead056a2c0a 100644 --- a/tests/baselines/reference/methodSignaturesWithOverloads2.types +++ b/tests/baselines/reference/methodSignaturesWithOverloads2.types @@ -54,7 +54,7 @@ var c2: { >x : T func4? (s: T): string; ->func4 : { (x: T_1): number; (s: T): string; } +>func4 : { (x: T_1): number; (s: T): string; } >s : T func5?: { diff --git a/tests/baselines/reference/missingTypeArguments3.types b/tests/baselines/reference/missingTypeArguments3.types index 38a989e8598f2..ca13db8148d37 100644 --- a/tests/baselines/reference/missingTypeArguments3.types +++ b/tests/baselines/reference/missingTypeArguments3.types @@ -14,7 +14,7 @@ declare module linq { >element : T GroupBy(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): Enumerable>; ->GroupBy : { (keySelector: (element: T) => TKey_1): Enumerable>; (keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): Enumerable>; } +>GroupBy : { (keySelector: (element: T) => TKey_1): Enumerable>; (keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): Enumerable>; } >keySelector : (element: T) => TKey >element : T >elementSelector : (element: T) => TElement diff --git a/tests/baselines/reference/mixinClassesAnnotated.types b/tests/baselines/reference/mixinClassesAnnotated.types index 9126092a44476..4f84de5a7fa25 100644 --- a/tests/baselines/reference/mixinClassesAnnotated.types +++ b/tests/baselines/reference/mixinClassesAnnotated.types @@ -36,8 +36,8 @@ interface Printable { } const Printable = >(superClass: T): Constructor & { message: string } & T => ->Printable : >(superClass: T) => Constructor & { message: string; } & T ->>(superClass: T): Constructor & { message: string } & T => class extends superClass { static message = "hello"; print() { const output = this.x + "," + this.y; } } : >(superClass: T) => Constructor & { message: string; } & T +>Printable : >(superClass: T) => Constructor & { message: string;} & T +>>(superClass: T): Constructor & { message: string } & T => class extends superClass { static message = "hello"; print() { const output = this.x + "," + this.y; } } : >(superClass: T) => Constructor & { message: string;} & T >superClass : T >message : string diff --git a/tests/baselines/reference/multipleInferenceContexts.types b/tests/baselines/reference/multipleInferenceContexts.types index e017122005564..30434ef960b49 100644 --- a/tests/baselines/reference/multipleInferenceContexts.types +++ b/tests/baselines/reference/multipleInferenceContexts.types @@ -22,7 +22,7 @@ interface Instance { } declare var Moon: { ->Moon : (options?: ConstructorOptions | undefined) => Instance +>Moon : (options?: ConstructorOptions) => Instance (options?: ConstructorOptions): Instance; >options : ConstructorOptions | undefined diff --git a/tests/baselines/reference/nearbyIdenticalGenericLambdasAssignable.types b/tests/baselines/reference/nearbyIdenticalGenericLambdasAssignable.types index 701903f38cfc4..f4b4b02016d9e 100644 --- a/tests/baselines/reference/nearbyIdenticalGenericLambdasAssignable.types +++ b/tests/baselines/reference/nearbyIdenticalGenericLambdasAssignable.types @@ -2,7 +2,7 @@ === nearbyIdenticalGenericLambdasAssignable.ts === declare const fA: () => { v: T }; ->fA : () => { v: T; } +>fA : () => { v: T;} >v : T const fB = () => { @@ -43,7 +43,7 @@ type TC = typeof fC; >fC : () => { v: T; } type TL = () => { v: T }; ->TL : () => { v: T; } +>TL : () => { v: T;} >v : T declare function accA(x: TA): void; diff --git a/tests/baselines/reference/noImplicitReturnsExclusions.types b/tests/baselines/reference/noImplicitReturnsExclusions.types index 1547993dbfa13..9ee2be8951683 100644 --- a/tests/baselines/reference/noImplicitReturnsExclusions.types +++ b/tests/baselines/reference/noImplicitReturnsExclusions.types @@ -159,7 +159,7 @@ interface Thenable { ): Thenable; then( ->then : { (onfulfilled?: ((value: T) => TResult_1 | Thenable) | undefined, onrejected?: ((reason: any) => TResult_1 | Thenable) | undefined): Thenable; (onfulfilled?: ((value: T) => TResult | Thenable) | undefined, onrejected?: ((reason: any) => void) | undefined): Thenable; } +>then : { (onfulfilled?: ((value: T) => TResult_1 | Thenable) | undefined, onrejected?: ((reason: any) => TResult_1 | Thenable) | undefined): Thenable; (onfulfilled?: ((value: T) => TResult | Thenable) | undefined, onrejected?: ((reason: any) => void) | undefined): Thenable; } onfulfilled?: (value: T) => TResult | Thenable, >onfulfilled : ((value: T) => TResult | Thenable) | undefined diff --git a/tests/baselines/reference/nodeModuleReexportFromDottedPath.types b/tests/baselines/reference/nodeModuleReexportFromDottedPath.types index ad3363dc2b126..34f6e20889611 100644 --- a/tests/baselines/reference/nodeModuleReexportFromDottedPath.types +++ b/tests/baselines/reference/nodeModuleReexportFromDottedPath.types @@ -22,7 +22,7 @@ import { PrismaClient } from "@prisma/client"; >PrismaClient : typeof PrismaClient declare const enhancePrisma: (client: TPrismaClientCtor) => TPrismaClientCtor & { enhanced: unknown }; ->enhancePrisma : (client: TPrismaClientCtor) => TPrismaClientCtor & { enhanced: unknown; } +>enhancePrisma : (client: TPrismaClientCtor) => TPrismaClientCtor & { enhanced: unknown;} >client : TPrismaClientCtor >enhanced : unknown diff --git a/tests/baselines/reference/nonInferrableTypePropagation2.types b/tests/baselines/reference/nonInferrableTypePropagation2.types index a8eda79ab8380..a878f1f4d97da 100644 --- a/tests/baselines/reference/nonInferrableTypePropagation2.types +++ b/tests/baselines/reference/nonInferrableTypePropagation2.types @@ -31,7 +31,7 @@ interface Refinement { } declare const filter: { ->filter : { (refinement: Refinement): (as: readonly A[]) => readonly B[]; (predicate: Predicate): (bs: readonly B_1[]) => readonly B_1[]; (predicate: Predicate): (as: readonly A_2[]) => readonly A_2[]; } +>filter : { (refinement: Refinement): (as: ReadonlyArray) => ReadonlyArray; (predicate: Predicate): (bs: readonly B_1[]) => readonly B_1[]; (predicate: Predicate): (as: readonly A_2[]) => readonly A_2[]; } (refinement: Refinement): (as: ReadonlyArray) => ReadonlyArray >refinement : Refinement diff --git a/tests/baselines/reference/objectLiteralParameterResolution.types b/tests/baselines/reference/objectLiteralParameterResolution.types index 16ee9499a694f..6ac06af5c299e 100644 --- a/tests/baselines/reference/objectLiteralParameterResolution.types +++ b/tests/baselines/reference/objectLiteralParameterResolution.types @@ -8,7 +8,7 @@ interface Foo{ >objs : any[] extend(deep: boolean, target: T, ...objs: any[]): T; ->extend : { (target: T_1, ...objs: any[]): T_1; (deep: boolean, target: T, ...objs: any[]): T; } +>extend : { (target: T_1, ...objs: any[]): T_1; (deep: boolean, target: T, ...objs: any[]): T; } >deep : boolean >target : T >objs : any[] diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.types b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.types index 2dcd983f62a0e..c045e076d973f 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.types +++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.types @@ -40,13 +40,13 @@ interface I2 { } var a: { foo(x: Z): Z } ->a : { foo(x: Z): Z; } +>a : { foo(x: Z): Z; } >foo : (x: Z) => Z >x : Z var b = { foo(x: A) { return x; } }; ->b : { foo(x: A_1): A_1; } ->{ foo(x: A) { return x; } } : { foo(x: A_1): A_1; } +>b : { foo(x: A): A; } +>{ foo(x: A) { return x; } } : { foo(x: A): A; } >foo : (x: A) => A >x : A >x : A @@ -100,31 +100,31 @@ function foo2(x: any) { } >x : any function foo3(x: typeof a); ->foo3 : { (x: typeof a): any; (x: { foo(x: Z): Z; }): any; } ->x : { foo(x: Z): Z; } ->a : { foo(x: Z): Z; } +>foo3 : { (x: typeof a): any; (x: { foo(x: Z): Z; }): any; } +>x : { foo(x: Z): Z; } +>a : { foo(x: Z): Z; } function foo3(x: typeof a); // error ->foo3 : { (x: { foo(x: Z): Z; }): any; (x: typeof a): any; } ->x : { foo(x: Z): Z; } ->a : { foo(x: Z): Z; } +>foo3 : { (x: { foo(x: Z): Z; }): any; (x: typeof a): any; } +>x : { foo(x: Z): Z; } +>a : { foo(x: Z): Z; } function foo3(x: any) { } ->foo3 : { (x: { foo(x: Z): Z; }): any; (x: { foo(x: Z): Z; }): any; } +>foo3 : { (x: { foo(x: Z): Z; }): any; (x: { foo(x: Z): Z; }): any; } >x : any function foo4(x: typeof b); ->foo4 : { (x: typeof b): any; (x: { foo(x: A_1): A_1; }): any; } ->x : { foo(x: A_1): A_1; } ->b : { foo(x: A_1): A_1; } +>foo4 : { (x: typeof b): any; (x: { foo(x: A): A; }): any; } +>x : { foo(x: A): A; } +>b : { foo(x: A): A; } function foo4(x: typeof b); // error ->foo4 : { (x: { foo(x: A_1): A_1; }): any; (x: typeof b): any; } ->x : { foo(x: A_1): A_1; } ->b : { foo(x: A_1): A_1; } +>foo4 : { (x: { foo(x: A): A; }): any; (x: typeof b): any; } +>x : { foo(x: A): A; } +>b : { foo(x: A): A; } function foo4(x: any) { } ->foo4 : { (x: { foo(x: A_1): A_1; }): any; (x: { foo(x: A_1): A_1; }): any; } +>foo4 : { (x: { foo(x: A): A; }): any; (x: { foo(x: A): A; }): any; } >x : any function foo5(x: A); @@ -164,16 +164,16 @@ function foo6(x: any) { } >x : any function foo7(x: A); ->foo7 : { (x: A): any; (x: { foo(x: Z): Z; }): any; } +>foo7 : { (x: A): any; (x: { foo(x: Z): Z; }): any; } >x : A function foo7(x: typeof a); // no error, bug? >foo7 : { (x: A): any; (x: typeof a): any; } ->x : { foo(x: Z): Z; } ->a : { foo(x: Z): Z; } +>x : { foo(x: Z): Z; } +>a : { foo(x: Z): Z; } function foo7(x: any) { } ->foo7 : { (x: A): any; (x: { foo(x: Z): Z; }): any; } +>foo7 : { (x: A): any; (x: { foo(x: Z): Z; }): any; } >x : any function foo8(x: B); @@ -201,29 +201,29 @@ function foo9(x: any) { } >x : any function foo10(x: B); ->foo10 : { (x: B): any; (x: { foo(x: Z): Z; }): any; } +>foo10 : { (x: B): any; (x: { foo(x: Z): Z; }): any; } >x : B function foo10(x: typeof a); // ok >foo10 : { (x: B): any; (x: typeof a): any; } ->x : { foo(x: Z): Z; } ->a : { foo(x: Z): Z; } +>x : { foo(x: Z): Z; } +>a : { foo(x: Z): Z; } function foo10(x: any) { } ->foo10 : { (x: B): any; (x: { foo(x: Z): Z; }): any; } +>foo10 : { (x: B): any; (x: { foo(x: Z): Z; }): any; } >x : any function foo11(x: B); ->foo11 : { (x: B): any; (x: { foo(x: A_1): A_1; }): any; } +>foo11 : { (x: B): any; (x: { foo(x: A): A; }): any; } >x : B function foo11(x: typeof b); // ok >foo11 : { (x: B): any; (x: typeof b): any; } ->x : { foo(x: A_1): A_1; } ->b : { foo(x: A_1): A_1; } +>x : { foo(x: A): A; } +>b : { foo(x: A): A; } function foo11(x: any) { } ->foo11 : { (x: B): any; (x: { foo(x: A_1): A_1; }): any; } +>foo11 : { (x: B): any; (x: { foo(x: A): A; }): any; } >x : any function foo12(x: I, number, Date, string>); @@ -251,29 +251,29 @@ function foo12b(x: any) { } >x : any function foo13(x: I); ->foo13 : { (x: I): any; (x: { foo(x: Z): Z; }): any; } +>foo13 : { (x: I): any; (x: { foo(x: Z): Z; }): any; } >x : I function foo13(x: typeof a); // ok >foo13 : { (x: I): any; (x: typeof a): any; } ->x : { foo(x: Z): Z; } ->a : { foo(x: Z): Z; } +>x : { foo(x: Z): Z; } +>a : { foo(x: Z): Z; } function foo13(x: any) { } ->foo13 : { (x: I): any; (x: { foo(x: Z): Z; }): any; } +>foo13 : { (x: I): any; (x: { foo(x: Z): Z; }): any; } >x : any function foo14(x: I); ->foo14 : { (x: I): any; (x: { foo(x: A_1): A_1; }): any; } +>foo14 : { (x: I): any; (x: { foo(x: A): A; }): any; } >x : I function foo14(x: typeof b); // ok >foo14 : { (x: I): any; (x: typeof b): any; } ->x : { foo(x: A_1): A_1; } ->b : { foo(x: A_1): A_1; } +>x : { foo(x: A): A; } +>b : { foo(x: A): A; } function foo14(x: any) { } ->foo14 : { (x: I): any; (x: { foo(x: A_1): A_1; }): any; } +>foo14 : { (x: I): any; (x: { foo(x: A): A; }): any; } >x : any function foo15(x: I2); diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.types b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.types index 71e4b96912eef..cb54b27ab74fc 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.types +++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterNames.types @@ -45,8 +45,8 @@ var a: { foo(x: Z): Z } >x : Z var b = { foo(x: A) { return x; } }; ->b : { foo(x: A_1): A_1; } ->{ foo(x: A) { return x; } } : { foo(x: A_1): A_1; } +>b : { foo(x: A): A; } +>{ foo(x: A) { return x; } } : { foo(x: A): A; } >foo : (x: A) => A >x : A >x : A @@ -114,17 +114,17 @@ function foo3(x: any) { } >x : any function foo4(x: typeof b); ->foo4 : { (x: typeof b): any; (x: { foo(x: A_1): A_1; }): any; } ->x : { foo(x: A_1): A_1; } ->b : { foo(x: A_1): A_1; } +>foo4 : { (x: typeof b): any; (x: { foo(x: A): A; }): any; } +>x : { foo(x: A): A; } +>b : { foo(x: A): A; } function foo4(x: typeof b); // error ->foo4 : { (x: { foo(x: A_1): A_1; }): any; (x: typeof b): any; } ->x : { foo(x: A_1): A_1; } ->b : { foo(x: A_1): A_1; } +>foo4 : { (x: { foo(x: A): A; }): any; (x: typeof b): any; } +>x : { foo(x: A): A; } +>b : { foo(x: A): A; } function foo4(x: any) { } ->foo4 : { (x: { foo(x: A_1): A_1; }): any; (x: { foo(x: A_1): A_1; }): any; } +>foo4 : { (x: { foo(x: A): A; }): any; (x: { foo(x: A): A; }): any; } >x : any function foo5(x: A); @@ -214,16 +214,16 @@ function foo10(x: any) { } >x : any function foo11(x: B); ->foo11 : { (x: B): any; (x: { foo(x: A_1): A_1; }): any; } +>foo11 : { (x: B): any; (x: { foo(x: A): A; }): any; } >x : B function foo11(x: typeof b); // ok >foo11 : { (x: B): any; (x: typeof b): any; } ->x : { foo(x: A_1): A_1; } ->b : { foo(x: A_1): A_1; } +>x : { foo(x: A): A; } +>b : { foo(x: A): A; } function foo11(x: any) { } ->foo11 : { (x: B): any; (x: { foo(x: A_1): A_1; }): any; } +>foo11 : { (x: B): any; (x: { foo(x: A): A; }): any; } >x : any function foo12(x: I); @@ -264,16 +264,16 @@ function foo13(x: any) { } >x : any function foo14(x: I); ->foo14 : { (x: I): any; (x: { foo(x: A_1): A_1; }): any; } +>foo14 : { (x: I): any; (x: { foo(x: A): A; }): any; } >x : I function foo14(x: typeof b); // ok >foo14 : { (x: I): any; (x: typeof b): any; } ->x : { foo(x: A_1): A_1; } ->b : { foo(x: A_1): A_1; } +>x : { foo(x: A): A; } +>b : { foo(x: A): A; } function foo14(x: any) { } ->foo14 : { (x: I): any; (x: { foo(x: A_1): A_1; }): any; } +>foo14 : { (x: I): any; (x: { foo(x: A): A; }): any; } >x : any function foo15(x: I2); diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types index ff0245a6f9fa7..477e469cc1482 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types +++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types @@ -28,12 +28,12 @@ interface I2 { } var a: { new (x: Z): C; } ->a : new (x: Z) => C +>a : new (x: Z) => C >x : Z var b = { new(x: A) { return x; } }; ->b : { "new"(x: A): A; } ->{ new(x: A) { return x; } } : { "new"(x: A): A; } +>b : { "new"(x: A): A; } +>{ new(x: A) { return x; } } : { "new"(x: A): A; } >new : (x: A) => A >x : A >x : A @@ -75,31 +75,31 @@ function foo2(x: any) { } >x : any function foo3(x: typeof a); ->foo3 : { (x: typeof a): any; (x: new (x: Z) => C): any; } ->x : new (x: Z) => C ->a : new (x: Z) => C +>foo3 : { (x: typeof a): any; (x: new (x: Z) => C): any; } +>x : new (x: Z) => C +>a : new (x: Z) => C function foo3(x: typeof a); // error ->foo3 : { (x: new (x: Z) => C): any; (x: typeof a): any; } ->x : new (x: Z) => C ->a : new (x: Z) => C +>foo3 : { (x: new (x: Z) => C): any; (x: typeof a): any; } +>x : new (x: Z) => C +>a : new (x: Z) => C function foo3(x: any) { } ->foo3 : { (x: new (x: Z) => C): any; (x: new (x: Z) => C): any; } +>foo3 : { (x: new (x: Z) => C): any; (x: new (x: Z) => C): any; } >x : any function foo4(x: typeof b); ->foo4 : { (x: typeof b): any; (x: { "new"(x: A): A; }): any; } ->x : { "new"(x: A): A; } ->b : { "new"(x: A): A; } +>foo4 : { (x: typeof b): any; (x: { "new"(x: A): A; }): any; } +>x : { "new"(x: A): A; } +>b : { "new"(x: A): A; } function foo4(x: typeof b); // error ->foo4 : { (x: { "new"(x: A): A; }): any; (x: typeof b): any; } ->x : { "new"(x: A): A; } ->b : { "new"(x: A): A; } +>foo4 : { (x: { "new"(x: A): A; }): any; (x: typeof b): any; } +>x : { "new"(x: A): A; } +>b : { "new"(x: A): A; } function foo4(x: any) { } ->foo4 : { (x: { "new"(x: A): A; }): any; (x: { "new"(x: A): A; }): any; } +>foo4 : { (x: { "new"(x: A): A; }): any; (x: { "new"(x: A): A; }): any; } >x : any function foo8(x: B); @@ -127,29 +127,29 @@ function foo9(x: any) { } >x : any function foo10(x: B); ->foo10 : { (x: B): any; (x: new (x: Z) => C): any; } +>foo10 : { (x: B): any; (x: new (x: Z) => C): any; } >x : B function foo10(x: typeof a); // ok >foo10 : { (x: B): any; (x: typeof a): any; } ->x : new (x: Z) => C ->a : new (x: Z) => C +>x : new (x: Z) => C +>a : new (x: Z) => C function foo10(x: any) { } ->foo10 : { (x: B): any; (x: new (x: Z) => C): any; } +>foo10 : { (x: B): any; (x: new (x: Z) => C): any; } >x : any function foo11(x: B); ->foo11 : { (x: B): any; (x: { "new"(x: A): A; }): any; } +>foo11 : { (x: B): any; (x: { "new"(x: A): A; }): any; } >x : B function foo11(x: typeof b); // ok >foo11 : { (x: B): any; (x: typeof b): any; } ->x : { "new"(x: A): A; } ->b : { "new"(x: A): A; } +>x : { "new"(x: A): A; } +>b : { "new"(x: A): A; } function foo11(x: any) { } ->foo11 : { (x: B): any; (x: { "new"(x: A): A; }): any; } +>foo11 : { (x: B): any; (x: { "new"(x: A): A; }): any; } >x : any function foo12(x: I, number, Date, string>); @@ -177,28 +177,28 @@ function foo12b(x: any) { } >x : any function foo13(x: I); ->foo13 : { (x: I): any; (x: new (x: Z) => C): any; } +>foo13 : { (x: I): any; (x: new (x: Z) => C): any; } >x : I function foo13(x: typeof a); // ok >foo13 : { (x: I): any; (x: typeof a): any; } ->x : new (x: Z) => C ->a : new (x: Z) => C +>x : new (x: Z) => C +>a : new (x: Z) => C function foo13(x: any) { } ->foo13 : { (x: I): any; (x: new (x: Z) => C): any; } +>foo13 : { (x: I): any; (x: new (x: Z) => C): any; } >x : any function foo14(x: I); ->foo14 : { (x: I): any; (x: { "new"(x: A): A; }): any; } +>foo14 : { (x: I): any; (x: { "new"(x: A): A; }): any; } >x : I function foo14(x: typeof b); // ok >foo14 : { (x: I): any; (x: typeof b): any; } ->x : { "new"(x: A): A; } ->b : { "new"(x: A): A; } +>x : { "new"(x: A): A; } +>b : { "new"(x: A): A; } function foo14(x: any) { } ->foo14 : { (x: I): any; (x: { "new"(x: A): A; }): any; } +>foo14 : { (x: I): any; (x: { "new"(x: A): A; }): any; } >x : any diff --git a/tests/baselines/reference/optionalParameterRetainsNull.types b/tests/baselines/reference/optionalParameterRetainsNull.types index ae9f3a4a3a11e..f64a90d213c1a 100644 --- a/tests/baselines/reference/optionalParameterRetainsNull.types +++ b/tests/baselines/reference/optionalParameterRetainsNull.types @@ -6,8 +6,8 @@ interface Bar { bar: number; foo: object | null; } >foo : object | null let a = { ->a : { test(a: K, b?: Bar[K] | null | undefined): void; } ->{ test (a: K, b?: Bar[K] | null) { }} : { test(a: K, b?: Bar[K] | null | undefined): void; } +>a : { test(a: K, b?: Bar[K] | null): void; } +>{ test (a: K, b?: Bar[K] | null) { }} : { test(a: K, b?: Bar[K] | null): void; } test (a: K, b?: Bar[K] | null) { } >test : (a: K, b?: Bar[K] | null) => void diff --git a/tests/baselines/reference/overloadEquivalenceWithStatics.types b/tests/baselines/reference/overloadEquivalenceWithStatics.types index 2afd40c7ebe65..47a35333f0de0 100644 --- a/tests/baselines/reference/overloadEquivalenceWithStatics.types +++ b/tests/baselines/reference/overloadEquivalenceWithStatics.types @@ -9,7 +9,7 @@ static B(v: A1): A1; // 1 >v : A1 static B(v: S): A1; // 2 : Error Duplicate signature ->B : { (v: A1): A1; (v: S): A1; } +>B : { (v: A1): A1; (v: S): A1; } >v : S static B(v: any): A1 { diff --git a/tests/baselines/reference/overloadResolution.types b/tests/baselines/reference/overloadResolution.types index 970c47c0f50c1..003b99092e0d8 100644 --- a/tests/baselines/reference/overloadResolution.types +++ b/tests/baselines/reference/overloadResolution.types @@ -114,13 +114,13 @@ function fn3(n: T): string; >n : T function fn3(s: string, t: T, u: U): U; ->fn3 : { (n: T_1): string; (s: string, t: T, u: U): U; (v: V, u: U_1, t: T_3): number; } +>fn3 : { (n: T_1): string; (s: string, t: T, u: U): U; (v: V, u: U_1, t: T_2): number; } >s : string >t : T >u : U function fn3(v: V, u: U, t: T): number; ->fn3 : { (n: T_1): string; (s: string, t: T_2, u: U_1): U_1; (v: V, u: U, t: T): number; } +>fn3 : { (n: T_1): string; (s: string, t: T_2, u: U_1): U_1; (v: V, u: U, t: T): number; } >v : V >u : U >t : T @@ -188,7 +188,7 @@ function fn4(n: T, m: U); >m : U function fn4(n: T, m: U); ->fn4 : { (n: T_1, m: U_1): any; (n: T, m: U): any; } +>fn4 : { (n: T_1, m: U_1): any; (n: T, m: U): any; } >n : T >m : U diff --git a/tests/baselines/reference/overloadedStaticMethodSpecialization.types b/tests/baselines/reference/overloadedStaticMethodSpecialization.types index 902e11e77e9e2..69dd2d648763a 100644 --- a/tests/baselines/reference/overloadedStaticMethodSpecialization.types +++ b/tests/baselines/reference/overloadedStaticMethodSpecialization.types @@ -9,7 +9,7 @@ class A { >v : A static B(v: S): A; ->B : { (v: A): A; (v: S): A; } +>B : { (v: A): A; (v: S): A; } >v : S static B(v: any): A { diff --git a/tests/baselines/reference/overloadsAndTypeArgumentArity.types b/tests/baselines/reference/overloadsAndTypeArgumentArity.types index e33e4b0877383..0d1eec202b40d 100644 --- a/tests/baselines/reference/overloadsAndTypeArgumentArity.types +++ b/tests/baselines/reference/overloadsAndTypeArgumentArity.types @@ -14,7 +14,7 @@ declare function Callbacks(flags?: string): void; >flags : string declare function Callbacks(flags?: string): void; ->Callbacks : { (flags?: string): void; (flags?: string): void; (flags?: string): void; (flags?: string): void; } +>Callbacks : { (flags?: string): void; (flags?: string): void; (flags?: string): void; (flags?: string): void; } >flags : string Callbacks('s'); // no error diff --git a/tests/baselines/reference/overloadsWithConstraints.types b/tests/baselines/reference/overloadsWithConstraints.types index f9987595196a8..c8e1df7f66442 100644 --- a/tests/baselines/reference/overloadsWithConstraints.types +++ b/tests/baselines/reference/overloadsWithConstraints.types @@ -6,7 +6,7 @@ declare function f(x: T): T; >x : T declare function f(x: T): T ->f : { (x: T_1): T_1; (x: T): T; } +>f : { (x: T_1): T_1; (x: T): T; } >x : T var v = f(""); diff --git a/tests/baselines/reference/override19.types b/tests/baselines/reference/override19.types index d075039baf17b..8aa0d3c811bed 100644 --- a/tests/baselines/reference/override19.types +++ b/tests/baselines/reference/override19.types @@ -27,7 +27,7 @@ class A { class B extends CreateMixin(Context, A) { >B : B >CreateMixin(Context, A) : A & { context: Context; } ->CreateMixin : (Context: C_1, Base: T) => T & (new (...args: any[]) => { context: InstanceType; }) +>CreateMixin : (Context: C, Base: T) => T & (new (...args: any[]) => { context: InstanceType; }) >Context : typeof Context >A : typeof A @@ -38,7 +38,7 @@ class B extends CreateMixin(Context, A) { class C extends CreateMixin(Context, A) { >C : C >CreateMixin(Context, A) : A & { context: Context; } ->CreateMixin : (Context: C_1, Base: T) => T & (new (...args: any[]) => { context: InstanceType; }) +>CreateMixin : (Context: C, Base: T) => T & (new (...args: any[]) => { context: InstanceType; }) >Context : typeof Context >A : typeof A diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.types b/tests/baselines/reference/parenthesizedContexualTyping1.types index 140e4acc2521c..7f7fe071a666e 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping1.types +++ b/tests/baselines/reference/parenthesizedContexualTyping1.types @@ -8,7 +8,7 @@ function fun(g: (x: T) => T, x: T): T; >x : T function fun(g: (x: T) => T, h: (y: T) => T, x: T): T; ->fun : { (g: (x: T_1) => T_1, x: T_1): T_1; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>fun : { (g: (x: T_1) => T_1, x: T_1): T_1; (g: (x: T) => T, h: (y: T) => T, x: T): T; } >g : (x: T) => T >x : T >h : (y: T) => T diff --git a/tests/baselines/reference/parenthesizedContexualTyping2.types b/tests/baselines/reference/parenthesizedContexualTyping2.types index 6b38396e89950..418eba21880b4 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping2.types +++ b/tests/baselines/reference/parenthesizedContexualTyping2.types @@ -19,7 +19,7 @@ function fun(f: FuncType, x: T): T; >x : T function fun(f: FuncType, g: FuncType, x: T): T; ->fun : { (f: FuncType, x: T_1): T_1; (f: FuncType, g: FuncType, x: T): T; } +>fun : { (f: FuncType, x: T_1): T_1; (f: FuncType, g: FuncType, x: T): T; } >f : FuncType >g : FuncType >x : T diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.types b/tests/baselines/reference/parenthesizedContexualTyping3.types index 5fcca9fb3d0c7..5db70aaa3862f 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping3.types +++ b/tests/baselines/reference/parenthesizedContexualTyping3.types @@ -14,7 +14,7 @@ function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; >x : T function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; ->tempFun : { (tempStrs: TemplateStringsArray, g: (x: T_1) => T_1, x: T_1): T_1; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T_1) => T_1, x: T_1): T_1; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } >tempStrs : TemplateStringsArray >g : (x: T) => T >x : T diff --git a/tests/baselines/reference/parseArrowFunctionWithFunctionReturnType.types b/tests/baselines/reference/parseArrowFunctionWithFunctionReturnType.types index 9454f587f2fb2..69aa9e1b8b316 100644 --- a/tests/baselines/reference/parseArrowFunctionWithFunctionReturnType.types +++ b/tests/baselines/reference/parseArrowFunctionWithFunctionReturnType.types @@ -2,7 +2,7 @@ === parseArrowFunctionWithFunctionReturnType.ts === const fn = (): (() => T) => null as any; ->fn : () => () => T ->(): (() => T) => null as any : () => () => T +>fn : () => (() => T) +>(): (() => T) => null as any : () => (() => T) >null as any : any diff --git a/tests/baselines/reference/promiseChaining.types b/tests/baselines/reference/promiseChaining.types index f0c1acfbedb49..625bf487ea05b 100644 --- a/tests/baselines/reference/promiseChaining.types +++ b/tests/baselines/reference/promiseChaining.types @@ -26,7 +26,7 @@ class Chain { >this.then(x => result)/*S*/.then(x => "abc")/*string*/.then(x => x.length) : Chain >this.then(x => result)/*S*/.then(x => "abc")/*string*/.then : (cb: (x: string) => S) => Chain >this.then(x => result)/*S*/.then(x => "abc") : Chain ->this.then(x => result)/*S*/.then : (cb: (x: S) => S) => Chain +>this.then(x => result)/*S*/.then : (cb: (x: S_1) => S) => Chain >this.then(x => result) : Chain >this.then : (cb: (x: T) => S) => Chain >this : this @@ -34,7 +34,7 @@ class Chain { >x => result : (x: T) => S >x : T >result : S ->then : (cb: (x: S) => S) => Chain +>then : (cb: (x: S_1) => S) => Chain >x => "abc" : (x: S) => string >x : S >"abc" : "abc" diff --git a/tests/baselines/reference/promiseChaining1.types b/tests/baselines/reference/promiseChaining1.types index f0e369b92f41a..035742be3da3b 100644 --- a/tests/baselines/reference/promiseChaining1.types +++ b/tests/baselines/reference/promiseChaining1.types @@ -28,7 +28,7 @@ class Chain2 { >this.then(x => result)/*S*/.then(x => "abc")/*Function*/.then(x => x.length) : Chain2 >this.then(x => result)/*S*/.then(x => "abc")/*Function*/.then : (cb: (x: Function) => S) => Chain2 >this.then(x => result)/*S*/.then(x => "abc") : Chain2 ->this.then(x => result)/*S*/.then : (cb: (x: S) => S) => Chain2 +>this.then(x => result)/*S*/.then : (cb: (x: S_1) => S) => Chain2 >this.then(x => result) : Chain2 >this.then : (cb: (x: T) => S) => Chain2 >this : this @@ -36,7 +36,7 @@ class Chain2 { >x => result : (x: T) => S >x : T >result : S ->then : (cb: (x: S) => S) => Chain2 +>then : (cb: (x: S_1) => S) => Chain2 >x => "abc" : (x: S) => string >x : S >"abc" : "abc" diff --git a/tests/baselines/reference/promiseChaining2.types b/tests/baselines/reference/promiseChaining2.types index 8407e4e87e0d6..55d2d6dad3aa1 100644 --- a/tests/baselines/reference/promiseChaining2.types +++ b/tests/baselines/reference/promiseChaining2.types @@ -28,7 +28,7 @@ class Chain2 { >this.then(x => result).then(x => "abc").then(x => x.length) : Chain2 >this.then(x => result).then(x => "abc").then : (cb: (x: Function) => S) => Chain2 >this.then(x => result).then(x => "abc") : Chain2 ->this.then(x => result).then : (cb: (x: S) => S) => Chain2 +>this.then(x => result).then : (cb: (x: S_1) => S) => Chain2 >this.then(x => result) : Chain2 >this.then : (cb: (x: T) => S) => Chain2 >this : this @@ -36,7 +36,7 @@ class Chain2 { >x => result : (x: T) => S >x : T >result : S ->then : (cb: (x: S) => S) => Chain2 +>then : (cb: (x: S_1) => S) => Chain2 >x => "abc" : (x: S) => string >x : S >"abc" : "abc" diff --git a/tests/baselines/reference/promisePermutations.types b/tests/baselines/reference/promisePermutations.types index e2fbf785100cd..c19694eb8c488 100644 --- a/tests/baselines/reference/promisePermutations.types +++ b/tests/baselines/reference/promisePermutations.types @@ -12,7 +12,7 @@ interface Promise { >progress : any then(success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_3, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): Promise; } +>then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_2, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): Promise; } >success : (value: T) => Promise >value : T >error : (error: any) => U @@ -21,7 +21,7 @@ interface Promise { >progress : any then(success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_2, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): Promise; } +>then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_2, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): Promise; } >success : (value: T) => U >value : T >error : (error: any) => Promise @@ -30,7 +30,7 @@ interface Promise { >progress : any then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_2, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_3, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +>then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_2, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_3, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } >success : (value: T) => U >value : T >error : (error: any) => U @@ -59,7 +59,7 @@ interface IPromise { >progress : any then(success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_2, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): IPromise; } >success : (value: T) => IPromise >value : T >error : (error: any) => U @@ -68,7 +68,7 @@ interface IPromise { >progress : any then(success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): IPromise; } >success : (value: T) => U >value : T >error : (error: any) => IPromise @@ -77,7 +77,7 @@ interface IPromise { >progress : any then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; } >success : (value: T) => U >value : T >error : (error: any) => U @@ -216,7 +216,7 @@ declare function testFunction12(x: T): IPromise; >x : T declare function testFunction12(x: T, y: T): IPromise; ->testFunction12 : { (x: T_1): IPromise; (x: T, y: T): IPromise; } +>testFunction12 : { (x: T_1): IPromise; (x: T, y: T): IPromise; } >x : T >y : T @@ -225,7 +225,7 @@ declare function testFunction12P(x: T): IPromise; >x : T declare function testFunction12P(x: T, y: T): Promise; ->testFunction12P : { (x: T_1): IPromise; (x: T, y: T): Promise; } +>testFunction12P : { (x: T_1): IPromise; (x: T, y: T): Promise; } >x : T >y : T diff --git a/tests/baselines/reference/promisePermutations2.types b/tests/baselines/reference/promisePermutations2.types index c0fbc5721c524..2ec0727731a1a 100644 --- a/tests/baselines/reference/promisePermutations2.types +++ b/tests/baselines/reference/promisePermutations2.types @@ -34,7 +34,7 @@ interface IPromise { >progress : any then(success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_2, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): IPromise; } >success : (value: T) => IPromise >value : T >error : (error: any) => U @@ -43,7 +43,7 @@ interface IPromise { >progress : any then(success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): IPromise; } >success : (value: T) => U >value : T >error : (error: any) => IPromise @@ -52,7 +52,7 @@ interface IPromise { >progress : any then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; ->then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; } +>then : { (success?: (value: T) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => IPromise, error?: (error: any) => U_2, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U_3, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; } >success : (value: T) => U >value : T >error : (error: any) => U @@ -191,7 +191,7 @@ declare function testFunction12(x: T): IPromise; >x : T declare function testFunction12(x: T, y: T): IPromise; ->testFunction12 : { (x: T_1): IPromise; (x: T, y: T): IPromise; } +>testFunction12 : { (x: T_1): IPromise; (x: T, y: T): IPromise; } >x : T >y : T @@ -200,7 +200,7 @@ declare function testFunction12P(x: T): IPromise; >x : T declare function testFunction12P(x: T, y: T): Promise; ->testFunction12P : { (x: T_1): IPromise; (x: T, y: T): Promise; } +>testFunction12P : { (x: T_1): IPromise; (x: T, y: T): Promise; } >x : T >y : T diff --git a/tests/baselines/reference/promisePermutations3.types b/tests/baselines/reference/promisePermutations3.types index dacc896422e0e..76cb0be4720e7 100644 --- a/tests/baselines/reference/promisePermutations3.types +++ b/tests/baselines/reference/promisePermutations3.types @@ -14,7 +14,7 @@ interface Promise { >progress : any then(success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_3, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): Promise; } +>then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_2, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): Promise; } >success : (value: T) => Promise >value : T >error : (error: any) => U @@ -23,7 +23,7 @@ interface Promise { >progress : any then(success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_2, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_4, error?: (error: any) => U_4, progress?: (progress: any) => void): Promise; } +>then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_2, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_3, error?: (error: any) => U_3, progress?: (progress: any) => void): Promise; } >success : (value: T) => U >value : T >error : (error: any) => Promise @@ -32,7 +32,7 @@ interface Promise { >progress : any then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_2, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_3, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +>then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_2, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_3, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } >success : (value: T) => U >value : T >error : (error: any) => U @@ -191,7 +191,7 @@ declare function testFunction12(x: T): IPromise; >x : T declare function testFunction12(x: T, y: T): IPromise; ->testFunction12 : { (x: T_1): IPromise; (x: T, y: T): IPromise; } +>testFunction12 : { (x: T_1): IPromise; (x: T, y: T): IPromise; } >x : T >y : T @@ -200,7 +200,7 @@ declare function testFunction12P(x: T): IPromise; >x : T declare function testFunction12P(x: T, y: T): Promise; ->testFunction12P : { (x: T_1): IPromise; (x: T, y: T): Promise; } +>testFunction12P : { (x: T_1): IPromise; (x: T, y: T): Promise; } >x : T >y : T diff --git a/tests/baselines/reference/promises.types b/tests/baselines/reference/promises.types index c330cd7e28f86..b7e683e379b4c 100644 --- a/tests/baselines/reference/promises.types +++ b/tests/baselines/reference/promises.types @@ -8,7 +8,7 @@ interface Promise { >value : T then(success?: (value: T) => Promise): Promise; ->then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => U_1): Promise; (success?: (value: T) => Promise): Promise; } +>then : { (onfulfilled?: (value: T) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: T) => U_1): Promise; (success?: (value: T) => Promise): Promise; } >success : (value: T) => Promise >value : T diff --git a/tests/baselines/reference/recursiveClassBaseType.types b/tests/baselines/reference/recursiveClassBaseType.types index aaff0f8485ebb..e32597c4977fa 100644 --- a/tests/baselines/reference/recursiveClassBaseType.types +++ b/tests/baselines/reference/recursiveClassBaseType.types @@ -8,7 +8,7 @@ declare const p: (fn: () => T) => T; >fn : () => T declare const Base: (val: T) => { new(): T }; ->Base : (val: T) => new () => T +>Base : (val: T) => { new (): T;} >val : T class C extends Base({ x: p(() => []) }) { } diff --git a/tests/baselines/reference/recursiveTypesUsedAsFunctionParameters.types b/tests/baselines/reference/recursiveTypesUsedAsFunctionParameters.types index d4198da0cde85..08ee6337246c5 100644 --- a/tests/baselines/reference/recursiveTypesUsedAsFunctionParameters.types +++ b/tests/baselines/reference/recursiveTypesUsedAsFunctionParameters.types @@ -76,11 +76,11 @@ function other, U>() { >x : T function foo5(x: List): number; ->foo5 : { (x: T): string; (x: List): number; (x: MyList): boolean; } +>foo5 : { (x: T): string; (x: List): number; (x: MyList): boolean; } >x : List function foo5(x: MyList): boolean; ->foo5 : { (x: T): string; (x: List): number; (x: MyList): boolean; } +>foo5 : { (x: T): string; (x: List): number; (x: MyList): boolean; } >x : MyList function foo5(x: any): any { return null; } diff --git a/tests/baselines/reference/specializationError.types b/tests/baselines/reference/specializationError.types index 6934a86a3b6ac..282706e271aa7 100644 --- a/tests/baselines/reference/specializationError.types +++ b/tests/baselines/reference/specializationError.types @@ -18,7 +18,7 @@ interface Bar { >element : string bar(value: string): Promise; ->bar : { (value: "Menu"): Promise; (value: string, element: string): Promise; (value: string): Promise; } +>bar : { (value: "Menu"): Promise; (value: string, element: string): Promise; (value: string): Promise; } >value : string } diff --git a/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.types b/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.types index 7674f238a3fd8..805ca6d29e10d 100644 --- a/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.types +++ b/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.types @@ -240,7 +240,7 @@ function f12(x: 'a'); >x : "a" function f12(x: T); ->f12 : { (x: "a"): any; (x: T): any; } +>f12 : { (x: "a"): any; (x: T): any; } >x : T function f12(x: any) { } @@ -252,7 +252,7 @@ function f13(x: 'a'); >x : "a" function f13(x: T); ->f13 : { (x: "a"): any; (x: T): any; } +>f13 : { (x: "a"): any; (x: T): any; } >x : T function f13(x: any) { } @@ -280,7 +280,7 @@ function f15(x: 'a'); >x : "a" function f15(x: U); ->f15 : { (x: "a"): any; (x: U): any; } +>f15 : { (x: "a"): any; (x: U): any; } >x : U function f15(x: any) { } @@ -292,7 +292,7 @@ function f16(x: 'a'); >x : "a" function f16(x: U); ->f16 : { (x: "a"): any; (x: U): any; } +>f16 : { (x: "a"): any; (x: U): any; } >x : U function f16(x: any) { } diff --git a/tests/baselines/reference/styledComponentsInstantiaionLimitNotReached.types b/tests/baselines/reference/styledComponentsInstantiaionLimitNotReached.types index bb4c363a0fc20..8f3eb7c82eb34 100644 --- a/tests/baselines/reference/styledComponentsInstantiaionLimitNotReached.types +++ b/tests/baselines/reference/styledComponentsInstantiaionLimitNotReached.types @@ -344,7 +344,7 @@ export interface StyledComponentBase< A | StyledComponentInnerAttrs >; withComponent>( ->withComponent : { (component: WithC_1): StyledComponent, T, O & StyledComponentInnerOtherProps, A | StyledComponentInnerAttrs>; >(component: WithC): StyledComponent; } +>withComponent : { (component: WithC_1): StyledComponent, T, O & StyledComponentInnerOtherProps, A | StyledComponentInnerAttrs>; >(component: WithC): StyledComponent; } >JSX : any >React : any diff --git a/tests/baselines/reference/subtypingWithCallSignatures2.types b/tests/baselines/reference/subtypingWithCallSignatures2.types index e58394becd6a1..56aacd670482e 100644 --- a/tests/baselines/reference/subtypingWithCallSignatures2.types +++ b/tests/baselines/reference/subtypingWithCallSignatures2.types @@ -706,8 +706,8 @@ var r13b = [r13arg2, r13arg1]; >r13arg1 : (x: Base[], y: T) => T var r14arg1 = (x: { a: T; b: T }) => x.a; ->r14arg1 : (x: { a: T; b: T; }) => T ->(x: { a: T; b: T }) => x.a : (x: { a: T; b: T; }) => T +>r14arg1 : (x: { a: T; b: T;}) => T +>(x: { a: T; b: T }) => x.a : (x: { a: T; b: T;}) => T >x : { a: T; b: T; } >a : T >b : T diff --git a/tests/baselines/reference/subtypingWithCallSignatures3.types b/tests/baselines/reference/subtypingWithCallSignatures3.types index 1cff2f0edf256..38349bb1ece68 100644 --- a/tests/baselines/reference/subtypingWithCallSignatures3.types +++ b/tests/baselines/reference/subtypingWithCallSignatures3.types @@ -377,8 +377,8 @@ module Errors { >r6arg2 : (x: Base[], y: Base[]) => T var r7arg = (x: { a: T; b: T }) => null; ->r7arg : (x: { a: T; b: T; }) => T ->(x: { a: T; b: T }) => null : (x: { a: T; b: T; }) => T +>r7arg : (x: { a: T; b: T;}) => T +>(x: { a: T; b: T }) => null : (x: { a: T; b: T;}) => T >x : { a: T; b: T; } >a : T >b : T @@ -411,8 +411,8 @@ module Errors { >r7arg2 : (x: { a: string; b: number; }) => number var r7arg3 = (x: { a: T; b: T }) => 1; ->r7arg3 : (x: { a: T; b: T; }) => number ->(x: { a: T; b: T }) => 1 : (x: { a: T; b: T; }) => number +>r7arg3 : (x: { a: T; b: T;}) => number +>(x: { a: T; b: T }) => 1 : (x: { a: T; b: T;}) => number >x : { a: T; b: T; } >a : T >b : T diff --git a/tests/baselines/reference/subtypingWithCallSignatures4.types b/tests/baselines/reference/subtypingWithCallSignatures4.types index 536f6fa021650..c5a74c6ba43fc 100644 --- a/tests/baselines/reference/subtypingWithCallSignatures4.types +++ b/tests/baselines/reference/subtypingWithCallSignatures4.types @@ -80,8 +80,8 @@ declare function foo6(a: any): any; >a : any declare function foo11(a11: (x: { foo: T }, y: { foo: T; bar: T }) => Base); ->foo11 : { (a11: (x: { foo: T; }, y: { foo: T; bar: T; }) => Base): any; (a: any): any; } ->a11 : (x: { foo: T; }, y: { foo: T; bar: T; }) => Base +>foo11 : { (a11: (x: { foo: T;}, y: { foo: T; bar: T;}) => Base): any; (a: any): any; } +>a11 : (x: { foo: T;}, y: { foo: T; bar: T;}) => Base >x : { foo: T; } >foo : T >y : { foo: T; bar: T; } @@ -93,8 +93,8 @@ declare function foo11(a: any): any; >a : any declare function foo15(a15: (x: { a: T; b: T }) => T[]); ->foo15 : { (a15: (x: { a: T; b: T; }) => T[]): any; (a: any): any; } ->a15 : (x: { a: T; b: T; }) => T[] +>foo15 : { (a15: (x: { a: T; b: T;}) => T[]): any; (a: any): any; } +>a15 : (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T @@ -104,8 +104,8 @@ declare function foo15(a: any): any; >a : any declare function foo16(a16: (x: { a: T; b: T }) => T[]); ->foo16 : { (a16: (x: { a: T; b: T; }) => T[]): any; (a: any): any; } ->a16 : (x: { a: T; b: T; }) => T[] +>foo16 : { (a16: (x: { a: T; b: T;}) => T[]): any; (a: any): any; } +>a16 : (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T @@ -348,8 +348,8 @@ var r6b = [r6arg2, r6arg]; >r6arg : (x: (arg: T) => U) => T var r11arg = (x: { foo: T }, y: { foo: U; bar: U }) => null; ->r11arg : (x: { foo: T; }, y: { foo: U; bar: U; }) => Base ->(x: { foo: T }, y: { foo: U; bar: U }) => null : (x: { foo: T; }, y: { foo: U; bar: U; }) => Base +>r11arg : (x: { foo: T;}, y: { foo: U; bar: U;}) => Base +>(x: { foo: T }, y: { foo: U; bar: U }) => null : (x: { foo: T;}, y: { foo: U; bar: U;}) => Base >x : { foo: T; } >foo : T >y : { foo: U; bar: U; } @@ -358,8 +358,8 @@ var r11arg = (x: { foo: T }, y: { foo: U; bar: U }) => null; >null : Base var r11arg2 = (x: { foo: T }, y: { foo: T; bar: T }) => null; ->r11arg2 : (x: { foo: T; }, y: { foo: T; bar: T; }) => Base ->(x: { foo: T }, y: { foo: T; bar: T }) => null : (x: { foo: T; }, y: { foo: T; bar: T; }) => Base +>r11arg2 : (x: { foo: T;}, y: { foo: T; bar: T;}) => Base +>(x: { foo: T }, y: { foo: T; bar: T }) => null : (x: { foo: T;}, y: { foo: T; bar: T;}) => Base >x : { foo: T; } >foo : T >y : { foo: T; bar: T; } @@ -386,16 +386,16 @@ var r11b = [r11arg2, r11arg]; >r11arg : (x: { foo: T; }, y: { foo: U; bar: U; }) => Base var r15arg = (x: { a: U; b: V; }) => null; ->r15arg : (x: { a: U; b: V; }) => U[] ->(x: { a: U; b: V; }) => null : (x: { a: U; b: V; }) => U[] +>r15arg : (x: { a: U; b: V;}) => U[] +>(x: { a: U; b: V; }) => null : (x: { a: U; b: V;}) => U[] >x : { a: U; b: V; } >a : U >b : V >null : U[] var r15arg2 = (x: { a: T; b: T }) => null; ->r15arg2 : (x: { a: T; b: T; }) => T[] ->(x: { a: T; b: T }) => null : (x: { a: T; b: T; }) => T[] +>r15arg2 : (x: { a: T; b: T;}) => T[] +>(x: { a: T; b: T }) => null : (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T @@ -420,16 +420,16 @@ var r15b = [r15arg2, r15arg]; >r15arg : (x: { a: U; b: V; }) => U[] var r16arg = (x: { a: T; b: T }) => null; ->r16arg : (x: { a: T; b: T; }) => T[] ->(x: { a: T; b: T }) => null : (x: { a: T; b: T; }) => T[] +>r16arg : (x: { a: T; b: T;}) => T[] +>(x: { a: T; b: T }) => null : (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T >null : T[] var r16arg2 = (x: { a: T; b: T }) => null; ->r16arg2 : (x: { a: T; b: T; }) => T[] ->(x: { a: T; b: T }) => null : (x: { a: T; b: T; }) => T[] +>r16arg2 : (x: { a: T; b: T;}) => T[] +>(x: { a: T; b: T }) => null : (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T diff --git a/tests/baselines/reference/subtypingWithConstructSignatures2.types b/tests/baselines/reference/subtypingWithConstructSignatures2.types index 9cf43fd1e83cf..2b4f592cd3f38 100644 --- a/tests/baselines/reference/subtypingWithConstructSignatures2.types +++ b/tests/baselines/reference/subtypingWithConstructSignatures2.types @@ -643,7 +643,7 @@ var r13b = [r13arg2, r13arg1]; >r13arg1 : new (x: Base[], y: T) => T var r14arg1: new (x: { a: T; b: T }) => T; ->r14arg1 : new (x: { a: T; b: T; }) => T +>r14arg1 : new (x: { a: T; b: T;}) => T >x : { a: T; b: T; } >a : T >b : T diff --git a/tests/baselines/reference/subtypingWithConstructSignatures3.types b/tests/baselines/reference/subtypingWithConstructSignatures3.types index 2c39d41384f87..7e2e81ca46cc7 100644 --- a/tests/baselines/reference/subtypingWithConstructSignatures3.types +++ b/tests/baselines/reference/subtypingWithConstructSignatures3.types @@ -349,7 +349,7 @@ module Errors { >r6arg2 : new (x: Base[], y: Base[]) => T var r7arg1: new (x: { a: T; b: T }) => T; ->r7arg1 : new (x: { a: T; b: T; }) => T +>r7arg1 : new (x: { a: T; b: T;}) => T >x : { a: T; b: T; } >a : T >b : T @@ -379,7 +379,7 @@ module Errors { >r7arg2 : new (x: { a: string; b: number; }) => number var r7arg3: new (x: { a: T; b: T }) => number; ->r7arg3 : new (x: { a: T; b: T; }) => number +>r7arg3 : new (x: { a: T; b: T;}) => number >x : { a: T; b: T; } >a : T >b : T diff --git a/tests/baselines/reference/subtypingWithConstructSignatures4.types b/tests/baselines/reference/subtypingWithConstructSignatures4.types index f85e667bb1b6f..fafea41492305 100644 --- a/tests/baselines/reference/subtypingWithConstructSignatures4.types +++ b/tests/baselines/reference/subtypingWithConstructSignatures4.types @@ -80,8 +80,8 @@ declare function foo6(a: any): any; >a : any declare function foo11(a11: new (x: { foo: T }, y: { foo: T; bar: T }) => Base); ->foo11 : { (a11: new (x: { foo: T; }, y: { foo: T; bar: T; }) => Base): any; (a: any): any; } ->a11 : new (x: { foo: T; }, y: { foo: T; bar: T; }) => Base +>foo11 : { (a11: new (x: { foo: T;}, y: { foo: T; bar: T;}) => Base): any; (a: any): any; } +>a11 : new (x: { foo: T;}, y: { foo: T; bar: T;}) => Base >x : { foo: T; } >foo : T >y : { foo: T; bar: T; } @@ -93,8 +93,8 @@ declare function foo11(a: any): any; >a : any declare function foo15(a15: new (x: { a: T; b: T }) => T[]); ->foo15 : { (a15: new (x: { a: T; b: T; }) => T[]): any; (a: any): any; } ->a15 : new (x: { a: T; b: T; }) => T[] +>foo15 : { (a15: new (x: { a: T; b: T;}) => T[]): any; (a: any): any; } +>a15 : new (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T @@ -104,8 +104,8 @@ declare function foo15(a: any): any; >a : any declare function foo16(a16: new (x: { a: T; b: T }) => T[]); ->foo16 : { (a16: new (x: { a: T; b: T; }) => T[]): any; (a: any): any; } ->a16 : new (x: { a: T; b: T; }) => T[] +>foo16 : { (a16: new (x: { a: T; b: T;}) => T[]): any; (a: any): any; } +>a16 : new (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T @@ -323,7 +323,7 @@ var r6b = [r6arg2, r6arg]; >r6arg : new (x: new (arg: T) => U) => T var r11arg: new (x: { foo: T }, y: { foo: U; bar: U }) => Base; ->r11arg : new (x: { foo: T; }, y: { foo: U; bar: U; }) => Base +>r11arg : new (x: { foo: T;}, y: { foo: U; bar: U;}) => Base >x : { foo: T; } >foo : T >y : { foo: U; bar: U; } @@ -331,7 +331,7 @@ var r11arg: new (x: { foo: T }, y: { foo: U; bar: U }) => Base; >bar : U var r11arg2: new (x: { foo: T }, y: { foo: T; bar: T }) => Base; ->r11arg2 : new (x: { foo: T; }, y: { foo: T; bar: T; }) => Base +>r11arg2 : new (x: { foo: T;}, y: { foo: T; bar: T;}) => Base >x : { foo: T; } >foo : T >y : { foo: T; bar: T; } @@ -357,13 +357,13 @@ var r11b = [r11arg2, r11arg]; >r11arg : new (x: { foo: T; }, y: { foo: U; bar: U; }) => Base var r15arg: new (x: { a: U; b: V; }) => U[]; ->r15arg : new (x: { a: U; b: V; }) => U[] +>r15arg : new (x: { a: U; b: V;}) => U[] >x : { a: U; b: V; } >a : U >b : V var r15arg2: new (x: { a: T; b: T }) => T[]; ->r15arg2 : new (x: { a: T; b: T; }) => T[] +>r15arg2 : new (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T @@ -387,13 +387,13 @@ var r15b = [r15arg2, r15arg]; >r15arg : new (x: { a: U; b: V; }) => U[] var r16arg: new (x: { a: T; b: T }) => T[]; ->r16arg : new (x: { a: T; b: T; }) => T[] +>r16arg : new (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T var r16arg2: new (x: { a: T; b: T }) => T[]; ->r16arg2 : new (x: { a: T; b: T; }) => T[] +>r16arg2 : new (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T diff --git a/tests/baselines/reference/subtypingWithConstructSignatures5.types b/tests/baselines/reference/subtypingWithConstructSignatures5.types index 5083e308cc679..601b34fb700c1 100644 --- a/tests/baselines/reference/subtypingWithConstructSignatures5.types +++ b/tests/baselines/reference/subtypingWithConstructSignatures5.types @@ -183,7 +183,7 @@ interface I extends B { >y : T a14: new (x: { a: T; b: U }) => T; // ok ->a14 : new (x: { a: T; b: U; }) => T +>a14 : new (x: { a: T; b: U;}) => T >x : { a: T; b: U; } >a : T >b : U diff --git a/tests/baselines/reference/subtypingWithConstructSignatures6.types b/tests/baselines/reference/subtypingWithConstructSignatures6.types index ee15eb9b4c042..b16692c6e3010 100644 --- a/tests/baselines/reference/subtypingWithConstructSignatures6.types +++ b/tests/baselines/reference/subtypingWithConstructSignatures6.types @@ -54,7 +54,7 @@ interface A { // T >arg : T a11: new (x: { foo: T }, y: { foo: T; bar: T }) => Base; ->a11 : new (x: { foo: T; }, y: { foo: T; bar: T; }) => Base +>a11 : new (x: { foo: T;}, y: { foo: T; bar: T;}) => Base >x : { foo: T; } >foo : T >y : { foo: T; bar: T; } @@ -62,13 +62,13 @@ interface A { // T >bar : T a15: new (x: { a: T; b: T }) => T[]; ->a15 : new (x: { a: T; b: T; }) => T[] +>a15 : new (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T a16: new (x: { a: T; b: T }) => T[]; ->a16 : new (x: { a: T; b: T; }) => T[] +>a16 : new (x: { a: T; b: T;}) => T[] >x : { a: T; b: T; } >a : T >b : T @@ -109,7 +109,7 @@ interface I5 extends A { interface I7 extends A { a11: new (x: { foo: T }, y: { foo: U; bar: U }) => Base; ->a11 : new (x: { foo: T;}, y: { foo: U; bar: U; }) => Base +>a11 : new (x: { foo: T;}, y: { foo: U; bar: U;}) => Base >x : { foo: T; } >foo : T >y : { foo: U; bar: U; } diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.types b/tests/baselines/reference/taggedTemplateContextualTyping1.types index 93e6ed32e6139..d2e9489fed556 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping1.types +++ b/tests/baselines/reference/taggedTemplateContextualTyping1.types @@ -14,7 +14,7 @@ function tempTag1(templateStrs: TemplateStringsArray, f: FuncType, x: T): T; >x : T function tempTag1(templateStrs: TemplateStringsArray, f: FuncType, h: FuncType, x: T): T; ->tempTag1 : { (templateStrs: TemplateStringsArray, f: FuncType, x: T_1): T_1; (templateStrs: TemplateStringsArray, f: FuncType, h: FuncType, x: T): T; } +>tempTag1 : { (templateStrs: TemplateStringsArray, f: FuncType, x: T_1): T_1; (templateStrs: TemplateStringsArray, f: FuncType, h: FuncType, x: T): T; } >templateStrs : TemplateStringsArray >f : FuncType >h : FuncType diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.types b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.types index d80a3bd5f9e31..188200780a6c0 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.types +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.types @@ -94,14 +94,14 @@ function fn3(strs: TemplateStringsArray, n: T): string; >n : T function fn3(strs: TemplateStringsArray, s: string, t: T, u: U): U; ->fn3 : { (strs: TemplateStringsArray, n: T_1): string; (strs: TemplateStringsArray, s: string, t: T, u: U): U; (strs: TemplateStringsArray, v: V, u: U_1, t: T_3): number; } +>fn3 : { (strs: TemplateStringsArray, n: T_1): string; (strs: TemplateStringsArray, s: string, t: T, u: U): U; (strs: TemplateStringsArray, v: V, u: U_1, t: T_2): number; } >strs : TemplateStringsArray >s : string >t : T >u : U function fn3(strs: TemplateStringsArray, v: V, u: U, t: T): number; ->fn3 : { (strs: TemplateStringsArray, n: T_1): string; (strs: TemplateStringsArray, s: string, t: T_2, u: U_1): U_1; (strs: TemplateStringsArray, v: V, u: U, t: T): number; } +>fn3 : { (strs: TemplateStringsArray, n: T_1): string; (strs: TemplateStringsArray, s: string, t: T_2, u: U_1): U_1; (strs: TemplateStringsArray, v: V, u: U, t: T): number; } >strs : TemplateStringsArray >v : V >u : U @@ -178,7 +178,7 @@ function fn4(strs: TemplateStringsArray, n: >m : U function fn4(strs: TemplateStringsArray, n: T, m: U); ->fn4 : { (strs: TemplateStringsArray, n: T_1, m: U_1): any; (strs: TemplateStringsArray, n: T, m: U): any; (strs: TemplateStringsArray): any; } +>fn4 : { (strs: TemplateStringsArray, n: T_1, m: U_1): any; (strs: TemplateStringsArray, n: T, m: U): any; (strs: TemplateStringsArray): any; } >strs : TemplateStringsArray >n : T >m : U diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.types b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.types index 602609d6d21d4..1b3b285f28013 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.types +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.types @@ -94,14 +94,14 @@ function fn3(strs: TemplateStringsArray, n: T): string; >n : T function fn3(strs: TemplateStringsArray, s: string, t: T, u: U): U; ->fn3 : { (strs: TemplateStringsArray, n: T_1): string; (strs: TemplateStringsArray, s: string, t: T, u: U): U; (strs: TemplateStringsArray, v: V, u: U_1, t: T_3): number; } +>fn3 : { (strs: TemplateStringsArray, n: T_1): string; (strs: TemplateStringsArray, s: string, t: T, u: U): U; (strs: TemplateStringsArray, v: V, u: U_1, t: T_2): number; } >strs : TemplateStringsArray >s : string >t : T >u : U function fn3(strs: TemplateStringsArray, v: V, u: U, t: T): number; ->fn3 : { (strs: TemplateStringsArray, n: T_1): string; (strs: TemplateStringsArray, s: string, t: T_2, u: U_1): U_1; (strs: TemplateStringsArray, v: V, u: U, t: T): number; } +>fn3 : { (strs: TemplateStringsArray, n: T_1): string; (strs: TemplateStringsArray, s: string, t: T_2, u: U_1): U_1; (strs: TemplateStringsArray, v: V, u: U, t: T): number; } >strs : TemplateStringsArray >v : V >u : U @@ -178,7 +178,7 @@ function fn4(strs: TemplateStringsArray, n: >m : U function fn4(strs: TemplateStringsArray, n: T, m: U); ->fn4 : { (strs: TemplateStringsArray, n: T_1, m: U_1): any; (strs: TemplateStringsArray, n: T, m: U): any; (strs: TemplateStringsArray): any; } +>fn4 : { (strs: TemplateStringsArray, n: T_1, m: U_1): any; (strs: TemplateStringsArray, n: T, m: U): any; (strs: TemplateStringsArray): any; } >strs : TemplateStringsArray >n : T >m : U diff --git a/tests/baselines/reference/taggedTemplatesWithTypeArguments1.types b/tests/baselines/reference/taggedTemplatesWithTypeArguments1.types index 22fd28158d7a3..3d9a23e9aaa8e 100644 --- a/tests/baselines/reference/taggedTemplatesWithTypeArguments1.types +++ b/tests/baselines/reference/taggedTemplatesWithTypeArguments1.types @@ -97,10 +97,10 @@ export const b = g ` `; declare let obj: { ->obj : { prop: (strs: TemplateStringsArray, x: (input: T) => T) => { returnedObjProp: T; }; } +>obj : { prop: (strs: TemplateStringsArray, x: (input: T) => T) => { returnedObjProp: T;}; } prop: (strs: TemplateStringsArray, x: (input: T) => T) => { ->prop : (strs: TemplateStringsArray, x: (input: T) => T) => { returnedObjProp: T; } +>prop : (strs: TemplateStringsArray, x: (input: T) => T) => { returnedObjProp: T;} >strs : TemplateStringsArray >x : (input: T) => T >input : T diff --git a/tests/baselines/reference/templateLiteralTypes1.types b/tests/baselines/reference/templateLiteralTypes1.types index 0ce03eed14e89..a84c4f20c8fc8 100644 --- a/tests/baselines/reference/templateLiteralTypes1.types +++ b/tests/baselines/reference/templateLiteralTypes1.types @@ -268,12 +268,12 @@ declare function getProppath : `${P0}.${P1}.${P2}` declare function getProp(obj: T, path: `${P0}.${P1}`): T[P0][P1]; ->getProp : { (obj: T_1, path: `${P0_1}.${P1_1}.${P2}`): T_1[P0_1][P1_1][P2]; (obj: T, path: `${P0}.${P1}`): T[P0][P1]; (obj: T_3, path: P0_3): T_3[P0_3]; (obj: object, path: string): unknown; } +>getProp : { (obj: T_1, path: `${P0_1}.${P1_1}.${P2}`): T_1[P0_1][P1_1][P2]; (obj: T, path: `${P0}.${P1}`): T[P0][P1]; (obj: T_2, path: P0_2): T_2[P0_2]; (obj: object, path: string): unknown; } >obj : T >path : `${P0}.${P1}` declare function getProp(obj: T, path: P0): T[P0]; ->getProp : { (obj: T_1, path: `${P0_1}.${P1}.${P2}`): T_1[P0_1][P1][P2]; (obj: T_2, path: `${P0_2}.${P1_1}`): T_2[P0_2][P1_1]; (obj: T, path: P0): T[P0]; (obj: object, path: string): unknown; } +>getProp : { (obj: T_1, path: `${P0_1}.${P1}.${P2}`): T_1[P0_1][P1][P2]; (obj: T_2, path: `${P0_2}.${P1_1}`): T_2[P0_2][P1_1]; (obj: T, path: P0): T[P0]; (obj: object, path: string): unknown; } >obj : T >path : P0 diff --git a/tests/baselines/reference/templateLiteralTypes3.types b/tests/baselines/reference/templateLiteralTypes3.types index 388a1f8e9b7f7..67115bf715ab6 100644 --- a/tests/baselines/reference/templateLiteralTypes3.types +++ b/tests/baselines/reference/templateLiteralTypes3.types @@ -395,7 +395,7 @@ declare function chain(field: F | `${F}.${F}`): void; chain("a"); >chain("a") : void ->chain : (field: F_1 | `${F_1}.${F_1}`) => void +>chain : (field: F | `${F}.${F}`) => void >"a" : "a" // Repro from #46125 diff --git a/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.types b/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.types index 9fff92177d3d4..39a4eda327e29 100644 --- a/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.types +++ b/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.types @@ -24,7 +24,7 @@ interface Combinators { >y : U map(c: Collection, f: (x: T, y: U) => any): Collection; ->map : { (c: Collection, f: (x: T_1, y: U_1) => V): Collection; (c: Collection, f: (x: T, y: U) => any): Collection; } +>map : { (c: Collection, f: (x: T_1, y: U_1) => V): Collection; (c: Collection, f: (x: T, y: U) => any): Collection; } >c : Collection >f : (x: T, y: U) => any >x : T diff --git a/tests/baselines/reference/tslibReExportHelpers2.types b/tests/baselines/reference/tslibReExportHelpers2.types index 8b36a5492ac4b..1c0b27ec23bd0 100644 --- a/tests/baselines/reference/tslibReExportHelpers2.types +++ b/tests/baselines/reference/tslibReExportHelpers2.types @@ -19,7 +19,7 @@ export declare function __classPrivateFieldGet( ): V; export declare function __classPrivateFieldGet unknown, V>( ->__classPrivateFieldGet : { (receiver: T_1, state: { has(o: T_1): boolean; get(o: T_1): V_1; }, kind?: "f"): V_1; unknown, V_2>(receiver: T, state: T, kind: "f", f: { value: V;}): V; } +>__classPrivateFieldGet : { (receiver: T_1, state: { has(o: T_1): boolean; get(o: T_1): V_1; }, kind?: "f"): V_1; unknown, V>(receiver: T, state: T, kind: "f", f: { value: V;}): V; } >args : any[] receiver: T, diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments3.types b/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments3.types index 4d452a55ff46c..98db4b9d6b071 100644 --- a/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments3.types +++ b/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments3.types @@ -9,7 +9,7 @@ declare function OverloadComponent(): JSX.Element; >JSX : any declare function OverloadComponent(attr: {b: U, a?: string, "ignore-prop": boolean}): JSX.Element; ->OverloadComponent : { (): JSX.Element; (attr: { b: U; a?: string; "ignore-prop": boolean;}): JSX.Element; (attr: { b: U_3; a: T; }): JSX.Element; } +>OverloadComponent : { (): JSX.Element; (attr: { b: U; a?: string; "ignore-prop": boolean;}): JSX.Element; (attr: { b: U_2; a: T; }): JSX.Element; } >attr : { b: U; a?: string; "ignore-prop": boolean; } >b : U >a : string @@ -17,7 +17,7 @@ declare function OverloadComponent(attr: {b: U, a?: string, "ignore-prop": bo >JSX : any declare function OverloadComponent(attr: {b: U, a: T}): JSX.Element; ->OverloadComponent : { (): JSX.Element; (attr: { b: U_2; a?: string; "ignore-prop": boolean; }): JSX.Element; (attr: { b: U; a: T;}): JSX.Element; } +>OverloadComponent : { (): JSX.Element; (attr: { b: U_2; a?: string; "ignore-prop": boolean; }): JSX.Element; (attr: { b: U; a: T;}): JSX.Element; } >attr : { b: U; a: T; } >b : U >a : T @@ -90,7 +90,7 @@ declare function Link(l: {func: (arg: U)=>void}): JSX.Element; >JSX : any declare function Link(l: {func: (arg1:U, arg2: string)=>void}): JSX.Element; ->Link : { (l: { func: (arg: U_1) => void; }): JSX.Element; (l: { func: (arg1: U, arg2: string) => void; }): JSX.Element; } +>Link : { (l: { func: (arg: U_1) => void; }): JSX.Element; (l: { func: (arg1: U, arg2: string) => void; }): JSX.Element; } >l : { func: (arg1: U, arg2: string) => void; } >func : (arg1: U, arg2: string) => void >arg1 : U diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments4.types b/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments4.types index c1f0a3ff7be49..17e91467582c5 100644 --- a/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments4.types +++ b/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments4.types @@ -9,7 +9,7 @@ declare function OverloadComponent(): JSX.Element; >JSX : any declare function OverloadComponent(attr: {b: U, a: string, "ignore-prop": boolean}): JSX.Element; ->OverloadComponent : { (): JSX.Element; (attr: { b: U; a: string; "ignore-prop": boolean;}): JSX.Element; (attr: { b: U_3; a: T; }): JSX.Element; } +>OverloadComponent : { (): JSX.Element; (attr: { b: U; a: string; "ignore-prop": boolean;}): JSX.Element; (attr: { b: U_2; a: T; }): JSX.Element; } >attr : { b: U; a: string; "ignore-prop": boolean; } >b : U >a : string @@ -17,7 +17,7 @@ declare function OverloadComponent(attr: {b: U, a: string, "ignore-prop": boo >JSX : any declare function OverloadComponent(attr: {b: U, a: T}): JSX.Element; ->OverloadComponent : { (): JSX.Element; (attr: { b: U_2; a: string; "ignore-prop": boolean; }): JSX.Element; (attr: { b: U; a: T;}): JSX.Element; } +>OverloadComponent : { (): JSX.Element; (attr: { b: U_2; a: string; "ignore-prop": boolean; }): JSX.Element; (attr: { b: U; a: T;}): JSX.Element; } >attr : { b: U; a: T; } >b : U >a : T diff --git a/tests/baselines/reference/tupleTypeInference.types b/tests/baselines/reference/tupleTypeInference.types index 5c20b00cf4921..fdf858abd3e54 100644 --- a/tests/baselines/reference/tupleTypeInference.types +++ b/tests/baselines/reference/tupleTypeInference.types @@ -10,11 +10,11 @@ interface IQService { >x : [IPromise, IPromise, IPromise] all(x: [IPromise, IPromise]): IPromise<[T1, T2]>; ->all : { (x: [IPromise, IPromise, IPromise]): IPromise<[T1_1, T2_1, T3]>; (x: [IPromise, IPromise]): IPromise<[T1, T2]>; (x: [IPromise]): IPromise<[T1_3]>; } +>all : { (x: [IPromise, IPromise, IPromise]): IPromise<[T1_1, T2_1, T3]>; (x: [IPromise, IPromise]): IPromise<[T1, T2]>; (x: [IPromise]): IPromise<[T1_2]>; } >x : [IPromise, IPromise] all(x: [IPromise]): IPromise<[T1]>; ->all : { (x: [IPromise, IPromise, IPromise]): IPromise<[T1_1, T2, T3]>; (x: [IPromise, IPromise]): IPromise<[T1_2, T2_1]>; (x: [IPromise]): IPromise<[T1]>; } +>all : { (x: [IPromise, IPromise, IPromise]): IPromise<[T1_1, T2, T3]>; (x: [IPromise, IPromise]): IPromise<[T1_2, T2_1]>; (x: [IPromise]): IPromise<[T1]>; } >x : [IPromise] when(t?: T): IPromise; diff --git a/tests/baselines/reference/twiceNestedKeyofIndexInference.types b/tests/baselines/reference/twiceNestedKeyofIndexInference.types index 52040db975a5e..68c0babf04bcc 100644 --- a/tests/baselines/reference/twiceNestedKeyofIndexInference.types +++ b/tests/baselines/reference/twiceNestedKeyofIndexInference.types @@ -22,7 +22,7 @@ declare function set(source: T, path: [K1], value: T[K1]) >value : T[K1] declare function set(source: T, path: [K1, K2], value: T[K1][K2]): Set2; ->set : { (source: T_1, path: [K1_1], value: T_1[K1_1]): Set1; (source: T, path: [K1, K2], value: T[K1][K2]): Set2; } +>set : { (source: T_1, path: [K1_1], value: T_1[K1_1]): Set1; (source: T, path: [K1, K2], value: T[K1][K2]): Set2; } >source : T >path : [K1, K2] >value : T[K1][K2] diff --git a/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.types b/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.types index 08934a5f14e0d..42ee590b400db 100644 --- a/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.types +++ b/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.types @@ -98,7 +98,7 @@ interface D { interface D { foo(x: W, y: W): T; ->foo : { (x: A_1, y: A_1): U; (x: W, y: W): T; } +>foo : { (x: A, y: A): U; (x: W, y: W): T; } >x : W >y : W } @@ -109,9 +109,9 @@ var d: D; var r3 = d.foo(1, 1); // boolean, last definition wins >r3 : boolean >d.foo(1, 1) : boolean ->d.foo : { (x: A_1, y: A_1): Date; (x: W, y: W): boolean; } +>d.foo : { (x: A, y: A): Date; (x: W, y: W): boolean; } >d : D ->foo : { (x: A_1, y: A_1): Date; (x: W, y: W): boolean; } +>foo : { (x: A, y: A): Date; (x: W, y: W): boolean; } >1 : 1 >1 : 1 diff --git a/tests/baselines/reference/typeAliases.types b/tests/baselines/reference/typeAliases.types index 9ae9eb2209130..28f9934eb3641 100644 --- a/tests/baselines/reference/typeAliases.types +++ b/tests/baselines/reference/typeAliases.types @@ -130,13 +130,13 @@ declare function foo13(t1: T1, t2: T13): void; foo13(x13_1, x13_2); >foo13(x13_1, x13_2) : void ->foo13 : (t1: T1_1, t2: I13) => void +>foo13 : (t1: T1, t2: I13) => void >x13_1 : I13 >x13_2 : I13 foo13(x13_2, x13_1); >foo13(x13_2, x13_1) : void ->foo13 : (t1: T1_1, t2: I13) => void +>foo13 : (t1: T1, t2: I13) => void >x13_2 : I13 >x13_1 : I13 diff --git a/tests/baselines/reference/typeArgumentConstraintResolution1.types b/tests/baselines/reference/typeArgumentConstraintResolution1.types index 331810369b696..ce8cf875f3e4c 100644 --- a/tests/baselines/reference/typeArgumentConstraintResolution1.types +++ b/tests/baselines/reference/typeArgumentConstraintResolution1.types @@ -6,7 +6,7 @@ function foo1(test: T); >test : T function foo1(test: string); ->foo1 : { (test: T_1): any; (test: string): any; } +>foo1 : { (test: T_1): any; (test: string): any; } >test : string function foo1(test: any) { } @@ -25,7 +25,7 @@ function foo2(test: T): T; >test : T function foo2(test: string): T; ->foo2 : { (test: T_1): T_1; (test: string): T; } +>foo2 : { (test: T_1): T_1; (test: string): T; } >test : string function foo2(test: any): any { return null; } diff --git a/tests/baselines/reference/typeParametersAreIdenticalToThemselves.types b/tests/baselines/reference/typeParametersAreIdenticalToThemselves.types index 5e2d463b83a9b..3fc62fcb89592 100644 --- a/tests/baselines/reference/typeParametersAreIdenticalToThemselves.types +++ b/tests/baselines/reference/typeParametersAreIdenticalToThemselves.types @@ -8,7 +8,7 @@ function foo1(x: T); >x : T function foo1(x: T); // no error, different declaration for each T ->foo1 : { (x: T_1): any; (x: T): any; } +>foo1 : { (x: T_1): any; (x: T): any; } >x : T function foo1(x: T) { } @@ -20,7 +20,7 @@ function foo2(x: T); >x : T function foo2(x: T); // no error, different declaration for each T ->foo2 : { (x: T_1): any; (x: T): any; } +>foo2 : { (x: T_1): any; (x: T): any; } >x : T function foo2(x: T) { } @@ -49,7 +49,7 @@ function foo3(x: T, y: U) { >x : T function inner2(x: T); // no error, different T ->inner2 : { (x: T): any; (x: T): any; } +>inner2 : { (x: T): any; (x: T_1): any; } >x : T function inner2(x: any) { } @@ -78,7 +78,7 @@ class C { >x : U foo2(a: T, x: U); // no error, different declaration for each U ->foo2 : { (a: T, x: U_1): any; (a: T, x: U): any; } +>foo2 : { (a: T, x: U_1): any; (a: T, x: U): any; } >a : T >x : U @@ -92,7 +92,7 @@ class C { >x : T foo3(x: T); // no error, different declaration for each T ->foo3 : { (x: T_1): any; (x: T): any; } +>foo3 : { (x: T_1): any; (x: T): any; } >x : T foo3(x: T) { } @@ -104,7 +104,7 @@ class C { >x : T foo4(x: T); // no error, different declaration for each T ->foo4 : { (x: T_1): any; (x: T): any; } +>foo4 : { (x: T_1): any; (x: T): any; } >x : T foo4(x: T) { } @@ -133,7 +133,7 @@ class C2 { >x : U foo2(a: T, x: U); // no error, different declaration for each U ->foo2 : { (a: T, x: U_1): any; (a: T, x: U): any; } +>foo2 : { (a: T, x: U_1): any; (a: T, x: U): any; } >a : T >x : U @@ -147,7 +147,7 @@ class C2 { >x : T foo3(x: T); // no error, different declaration for each T ->foo3 : { (x: T_1): any; (x: T): any; } +>foo3 : { (x: T_1): any; (x: T): any; } >x : T foo3(x: T) { } @@ -170,7 +170,7 @@ interface I { >x : U foo2(a: T, x: U); // no error, different declaration for each U ->foo2 : { (a: T, x: U_1): any; (a: T, x: U): any; } +>foo2 : { (a: T, x: U_1): any; (a: T, x: U): any; } >a : T >x : U @@ -179,7 +179,7 @@ interface I { >x : T foo3(x: T); // no error, different declaration for each T ->foo3 : { (x: T_1): any; (x: T): any; } +>foo3 : { (x: T_1): any; (x: T): any; } >x : T foo4(x: T); @@ -187,7 +187,7 @@ interface I { >x : T foo4(x: T); // no error, different declaration for each T ->foo4 : { (x: T_1): any; (x: T): any; } +>foo4 : { (x: T_1): any; (x: T): any; } >x : T } @@ -206,7 +206,7 @@ interface I2 { >x : U foo2(a: T, x: U); // no error, different declaration for each U ->foo2 : { (a: T, x: U_1): any; (a: T, x: U): any; } +>foo2 : { (a: T, x: U_1): any; (a: T, x: U): any; } >a : T >x : U @@ -215,6 +215,6 @@ interface I2 { >x : T foo3(x: T); // no error, different declaration for each T ->foo3 : { (x: T_1): any; (x: T): any; } +>foo3 : { (x: T_1): any; (x: T): any; } >x : T } diff --git a/tests/baselines/reference/undefinedTypeArgument2.types b/tests/baselines/reference/undefinedTypeArgument2.types index cc4dc7eba2b18..bec03282c2935 100644 --- a/tests/baselines/reference/undefinedTypeArgument2.types +++ b/tests/baselines/reference/undefinedTypeArgument2.types @@ -9,7 +9,7 @@ interface Query { >item : T selectMany(arraySelector: (item: T) => U[], resultSelector: (outer: T, inner: U) => R): Query; ->selectMany : { (selector: (item: T) => U_1[]): Query; (arraySelector: (item: T) => U[], resultSelector: (outer: T, inner: U) => R): Query; } +>selectMany : { (selector: (item: T) => U_1[]): Query; (arraySelector: (item: T) => U[], resultSelector: (outer: T, inner: U) => R): Query; } >arraySelector : (item: T) => U[] >item : T >resultSelector : (outer: T, inner: U) => R diff --git a/tests/baselines/reference/underscoreTest1.types b/tests/baselines/reference/underscoreTest1.types index d76badc5861c7..25a70dcc7e165 100644 --- a/tests/baselines/reference/underscoreTest1.types +++ b/tests/baselines/reference/underscoreTest1.types @@ -3229,11 +3229,11 @@ module Underscore { >list : T[] chain(list: Dictionary): ChainedDictionary; ->chain : { (list: T_1[]): ChainedArray; (list: Dictionary): ChainedDictionary; (obj: T_3): ChainedObject; } +>chain : { (list: T_1[]): ChainedArray; (list: Dictionary): ChainedDictionary; (obj: T_2): ChainedObject; } >list : Dictionary chain(obj: T): ChainedObject; ->chain : { (list: T_1[]): ChainedArray; (list: Dictionary): ChainedDictionary; (obj: T): ChainedObject; } +>chain : { (list: T_1[]): ChainedArray; (list: Dictionary): ChainedDictionary; (obj: T): ChainedObject; } >obj : T each(list: T[], iterator: Iterator_, context?: any): void; @@ -3243,7 +3243,7 @@ module Underscore { >context : any each(list: Dictionary, iterator: Iterator_, context?: any): void; ->each : { (list: T_1[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } +>each : { (list: T_1[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3255,7 +3255,7 @@ module Underscore { >context : any forEach(list: Dictionary, iterator: Iterator_, context?: any): void; ->forEach : { (list: T_1[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } +>forEach : { (list: T_1[], iterator: Iterator_, context?: any): void; (list: Dictionary, iterator: Iterator_, context?: any): void; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3267,7 +3267,7 @@ module Underscore { >context : any map(list: Dictionary, iterator: Iterator_, context?: any): U[]; ->map : { (list: T_1[], iterator: Iterator_, context?: any): U_1[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } +>map : { (list: T_1[], iterator: Iterator_, context?: any): U_1[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3279,7 +3279,7 @@ module Underscore { >context : any collect(list: Dictionary, iterator: Iterator_, context?: any): U[]; ->collect : { (list: T_1[], iterator: Iterator_, context?: any): U_1[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } +>collect : { (list: T_1[], iterator: Iterator_, context?: any): U_1[]; (list: Dictionary, iterator: Iterator_, context?: any): U[]; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3292,21 +3292,21 @@ module Underscore { >context : any reduce(list: T[], iterator: Reducer, initialValue: U, context?: any): U; ->reduce : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } +>reduce : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T_2, context?: any): T_2; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } >list : T[] >iterator : Reducer >initialValue : U >context : any reduce(list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; ->reduce : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } +>reduce : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } >list : Dictionary >iterator : Reducer >initialValue : T >context : any reduce(list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; ->reduce : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U_1, context?: any): U_1; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; } +>reduce : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U_1, context?: any): U_1; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; } >list : Dictionary >iterator : Reducer >initialValue : U @@ -3320,21 +3320,21 @@ module Underscore { >context : any foldl(list: T[], iterator: Reducer, initialValue: U, context?: any): U; ->foldl : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } +>foldl : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T_2, context?: any): T_2; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } >list : T[] >iterator : Reducer >initialValue : U >context : any foldl(list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; ->foldl : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } +>foldl : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } >list : Dictionary >iterator : Reducer >initialValue : T >context : any foldl(list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; ->foldl : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U_1, context?: any): U_1; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; } +>foldl : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U_1, context?: any): U_1; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; } >list : Dictionary >iterator : Reducer >initialValue : U @@ -3348,21 +3348,21 @@ module Underscore { >context : any inject(list: T[], iterator: Reducer, initialValue: U, context?: any): U; ->inject : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } +>inject : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T_2, context?: any): T_2; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } >list : T[] >iterator : Reducer >initialValue : U >context : any inject(list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; ->inject : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } +>inject : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } >list : Dictionary >iterator : Reducer >initialValue : T >context : any inject(list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; ->inject : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U_1, context?: any): U_1; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; } +>inject : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U_1, context?: any): U_1; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; } >list : Dictionary >iterator : Reducer >initialValue : U @@ -3376,21 +3376,21 @@ module Underscore { >context : any reduceRight(list: T[], iterator: Reducer, initialValue: U, context?: any): U; ->reduceRight : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } +>reduceRight : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T_2, context?: any): T_2; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } >list : T[] >iterator : Reducer >initialValue : U >context : any reduceRight(list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; ->reduceRight : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } +>reduceRight : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } >list : Dictionary >iterator : Reducer >initialValue : T >context : any reduceRight(list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; ->reduceRight : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U_1, context?: any): U_1; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; } +>reduceRight : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U_1, context?: any): U_1; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; } >list : Dictionary >iterator : Reducer >initialValue : U @@ -3404,21 +3404,21 @@ module Underscore { >context : any foldr(list: T[], iterator: Reducer, initialValue: U, context?: any): U; ->foldr : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } +>foldr : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T_2, context?: any): T_2; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } >list : T[] >iterator : Reducer >initialValue : U >context : any foldr(list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; ->foldr : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } +>foldr : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U, context?: any): U; (list: Dictionary, iterator: Reducer, initialValue?: T, context?: any): T; (list: Dictionary, iterator: Reducer, initialValue: U_1, context?: any): U_1; } >list : Dictionary >iterator : Reducer >initialValue : T >context : any foldr(list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; ->foldr : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U_1, context?: any): U_1; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; } +>foldr : { (list: T_1[], iterator: Reducer, initialValue?: T_1, context?: any): T_1; (list: T_2[], iterator: Reducer, initialValue: U_1, context?: any): U_1; (list: Dictionary, iterator: Reducer, initialValue?: T_3, context?: any): T_3; (list: Dictionary, iterator: Reducer, initialValue: U, context?: any): U; } >list : Dictionary >iterator : Reducer >initialValue : U @@ -3431,7 +3431,7 @@ module Underscore { >context : any find(list: Dictionary, iterator: Iterator_, context?: any): T; ->find : { (list: T_1[], iterator: Iterator_, context?: any): T_1; (list: Dictionary, iterator: Iterator_, context?: any): T; } +>find : { (list: T_1[], iterator: Iterator_, context?: any): T_1; (list: Dictionary, iterator: Iterator_, context?: any): T; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3443,7 +3443,7 @@ module Underscore { >context : any detect(list: Dictionary, iterator: Iterator_, context?: any): T; ->detect : { (list: T_1[], iterator: Iterator_, context?: any): T_1; (list: Dictionary, iterator: Iterator_, context?: any): T; } +>detect : { (list: T_1[], iterator: Iterator_, context?: any): T_1; (list: Dictionary, iterator: Iterator_, context?: any): T; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3455,7 +3455,7 @@ module Underscore { >context : any filter(list: Dictionary, iterator: Iterator_, context?: any): T[]; ->filter : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } +>filter : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3467,7 +3467,7 @@ module Underscore { >context : any select(list: Dictionary, iterator: Iterator_, context?: any): T[]; ->select : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } +>select : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3478,7 +3478,7 @@ module Underscore { >properties : Object where(list: Dictionary, properties: Object): T[]; ->where : { (list: T_1[], properties: Object): T_1[]; (list: Dictionary, properties: Object): T[]; } +>where : { (list: T_1[], properties: Object): T_1[]; (list: Dictionary, properties: Object): T[]; } >list : Dictionary >properties : Object @@ -3488,7 +3488,7 @@ module Underscore { >properties : Object findWhere(list: Dictionary, properties: Object): T; ->findWhere : { (list: T_1[], properties: Object): T_1; (list: Dictionary, properties: Object): T; } +>findWhere : { (list: T_1[], properties: Object): T_1; (list: Dictionary, properties: Object): T; } >list : Dictionary >properties : Object @@ -3499,7 +3499,7 @@ module Underscore { >context : any reject(list: Dictionary, iterator: Iterator_, context?: any): T[]; ->reject : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } +>reject : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3511,7 +3511,7 @@ module Underscore { >context : any every(list: Dictionary, iterator?: Iterator_, context?: any): boolean; ->every : { (list: T_1[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } +>every : { (list: T_1[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3523,7 +3523,7 @@ module Underscore { >context : any all(list: Dictionary, iterator?: Iterator_, context?: any): boolean; ->all : { (list: T_1[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } +>all : { (list: T_1[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3535,7 +3535,7 @@ module Underscore { >context : any some(list: Dictionary, iterator?: Iterator_, context?: any): boolean; ->some : { (list: T_1[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } +>some : { (list: T_1[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3547,7 +3547,7 @@ module Underscore { >context : any any(list: Dictionary, iterator?: Iterator_, context?: any): boolean; ->any : { (list: T_1[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } +>any : { (list: T_1[], iterator?: Iterator_, context?: any): boolean; (list: Dictionary, iterator?: Iterator_, context?: any): boolean; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3558,7 +3558,7 @@ module Underscore { >value : T contains(list: Dictionary, value: T): boolean; ->contains : { (list: T_1[], value: T_1): boolean; (list: Dictionary, value: T): boolean; } +>contains : { (list: T_1[], value: T_1): boolean; (list: Dictionary, value: T): boolean; } >list : Dictionary >value : T @@ -3568,7 +3568,7 @@ module Underscore { >value : T include(list: Dictionary, value: T): boolean; ->include : { (list: T_1[], value: T_1): boolean; (list: Dictionary, value: T): boolean; } +>include : { (list: T_1[], value: T_1): boolean; (list: Dictionary, value: T): boolean; } >list : Dictionary >value : T @@ -3601,7 +3601,7 @@ module Underscore { >context : any max(list: Dictionary, iterator?: Iterator_, context?: any): T; ->max : { (list: T_1[], iterator?: Iterator_, context?: any): T_1; (list: Dictionary, iterator?: Iterator_, context?: any): T; } +>max : { (list: T_1[], iterator?: Iterator_, context?: any): T_1; (list: Dictionary, iterator?: Iterator_, context?: any): T; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3613,7 +3613,7 @@ module Underscore { >context : any min(list: Dictionary, iterator?: Iterator_, context?: any): T; ->min : { (list: T_1[], iterator?: Iterator_, context?: any): T_1; (list: Dictionary, iterator?: Iterator_, context?: any): T; } +>min : { (list: T_1[], iterator?: Iterator_, context?: any): T_1; (list: Dictionary, iterator?: Iterator_, context?: any): T; } >list : Dictionary >iterator : Iterator_ >context : any @@ -3625,18 +3625,18 @@ module Underscore { >context : any sortBy(list: Dictionary, iterator: Iterator_, context?: any): T[]; ->sortBy : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; (list: T_3[], propertyName: string): T_3[]; (list: Dictionary, propertyName: string): T_4[]; } +>sortBy : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T[]; (list: T_2[], propertyName: string): T_2[]; (list: Dictionary, propertyName: string): T_3[]; } >list : Dictionary >iterator : Iterator_ >context : any sortBy(list: T[], propertyName: string): T[]; ->sortBy : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T_2[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T_4[]; } +>sortBy : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T_2[]; (list: T[], propertyName: string): T[]; (list: Dictionary, propertyName: string): T_3[]; } >list : T[] >propertyName : string sortBy(list: Dictionary, propertyName: string): T[]; ->sortBy : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T_2[]; (list: T_3[], propertyName: string): T_3[]; (list: Dictionary, propertyName: string): T[]; } +>sortBy : { (list: T_1[], iterator: Iterator_, context?: any): T_1[]; (list: Dictionary, iterator: Iterator_, context?: any): T_2[]; (list: T_3[], propertyName: string): T_3[]; (list: Dictionary, propertyName: string): T[]; } >list : Dictionary >propertyName : string @@ -3647,18 +3647,18 @@ module Underscore { >context : any groupBy(list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; ->groupBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T_3[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>groupBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T_2[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >list : Dictionary >iterator : Iterator_ >context : any groupBy(list: T[], propertyName: string): Dictionary; ->groupBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>groupBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >list : T[] >propertyName : string groupBy(list: Dictionary, propertyName: string): Dictionary; ->groupBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T_3[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>groupBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T_3[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >list : Dictionary >propertyName : string @@ -3669,18 +3669,18 @@ module Underscore { >context : any countBy(list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; ->countBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T_3[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>countBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T_2[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >list : Dictionary >iterator : Iterator_ >context : any countBy(list: T[], propertyName: string): Dictionary; ->countBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>countBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >list : T[] >propertyName : string countBy(list: Dictionary, propertyName: string): Dictionary; ->countBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T_3[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } +>countBy : { (list: T_1[], iterator?: Iterator_, context?: any): Dictionary; (list: Dictionary, iterator?: Iterator_, context?: any): Dictionary; (list: T_3[], propertyName: string): Dictionary; (list: Dictionary, propertyName: string): Dictionary; } >list : Dictionary >propertyName : string @@ -3689,7 +3689,7 @@ module Underscore { >list : T[] shuffle(list: Dictionary): T[]; ->shuffle : { (list: T_1[]): T_1[]; (list: Dictionary): T[]; } +>shuffle : { (list: T_1[]): T_1[]; (list: Dictionary): T[]; } >list : Dictionary toArray(list: T[]): T[]; @@ -3697,7 +3697,7 @@ module Underscore { >list : T[] toArray(list: Dictionary): T[]; ->toArray : { (list: T_1[]): T_1[]; (list: Dictionary): T[]; } +>toArray : { (list: T_1[]): T_1[]; (list: Dictionary): T[]; } >list : Dictionary size(list: T[]): number; @@ -3705,7 +3705,7 @@ module Underscore { >list : T[] size(list: Dictionary): number; ->size : { (list: T_1[]): number; (list: Dictionary): number; } +>size : { (list: T_1[]): number; (list: Dictionary): number; } >list : Dictionary first(list: T[]): T; @@ -3713,7 +3713,7 @@ module Underscore { >list : T[] first(list: T[], count: number): T[]; ->first : { (list: T_1[]): T_1; (list: T[], count: number): T[]; } +>first : { (list: T_1[]): T_1; (list: T[], count: number): T[]; } >list : T[] >count : number @@ -3722,7 +3722,7 @@ module Underscore { >list : T[] head(list: T[], count: number): T[]; ->head : { (list: T_1[]): T_1; (list: T[], count: number): T[]; } +>head : { (list: T_1[]): T_1; (list: T[], count: number): T[]; } >list : T[] >count : number @@ -3731,7 +3731,7 @@ module Underscore { >list : T[] take(list: T[], count: number): T[]; ->take : { (list: T_1[]): T_1; (list: T[], count: number): T[]; } +>take : { (list: T_1[]): T_1; (list: T[], count: number): T[]; } >list : T[] >count : number @@ -3740,7 +3740,7 @@ module Underscore { >list : T[] initial(list: T[], count: number): T[]; ->initial : { (list: T_1[]): T_1; (list: T[], count: number): T[]; } +>initial : { (list: T_1[]): T_1; (list: T[], count: number): T[]; } >list : T[] >count : number @@ -3749,7 +3749,7 @@ module Underscore { >list : T[] last(list: T[], count: number): T[]; ->last : { (list: T_1[]): T_1; (list: T[], count: number): T[]; } +>last : { (list: T_1[]): T_1; (list: T[], count: number): T[]; } >list : T[] >count : number @@ -3767,7 +3767,7 @@ module Underscore { >list : T[][] flatten(array: any[], shallow?: boolean): T[]; ->flatten : { (list: T_1[][]): T_1[]; (array: any[], shallow?: boolean): T[]; } +>flatten : { (list: T_1[][]): T_1[]; (array: any[], shallow?: boolean): T[]; } >array : any[] >shallow : boolean @@ -3795,7 +3795,7 @@ module Underscore { >isSorted : boolean uniq(list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; ->uniq : { (list: T_1[], isSorted?: boolean): T_1[]; (list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; } +>uniq : { (list: T_1[], isSorted?: boolean): T_1[]; (list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >list : T[] >isSorted : boolean >iterator : Iterator_ @@ -3807,7 +3807,7 @@ module Underscore { >isSorted : boolean unique(list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; ->unique : { (list: T_1[], isSorted?: boolean): T_1[]; (list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; } +>unique : { (list: T_1[], isSorted?: boolean): T_1[]; (list: T[], isSorted: boolean, iterator: Iterator_, context?: any): U[]; } >list : T[] >isSorted : boolean >iterator : Iterator_ @@ -3819,13 +3819,13 @@ module Underscore { >a1 : T1[] zip(a0: T0[], a1: T1[], a2: T2[]): Tuple3[]; ->zip : { (a0: T0_1[], a1: T1_1[]): Tuple2[]; (a0: T0[], a1: T1[], a2: T2[]): Tuple3[]; (a0: T0_3[], a1: T1_3[], a2: T2_1[], a3: T3[]): Tuple4[]; (...arrays: any[][]): any[][]; } +>zip : { (a0: T0_1[], a1: T1_1[]): Tuple2[]; (a0: T0[], a1: T1[], a2: T2[]): Tuple3[]; (a0: T0_2[], a1: T1_2[], a2: T2_1[], a3: T3[]): Tuple4[]; (...arrays: any[][]): any[][]; } >a0 : T0[] >a1 : T1[] >a2 : T2[] zip(a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4[]; ->zip : { (a0: T0_1[], a1: T1_1[]): Tuple2[]; (a0: T0_2[], a1: T1_2[], a2: T2_1[]): Tuple3[]; (a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4[]; (...arrays: any[][]): any[][]; } +>zip : { (a0: T0_1[], a1: T1_1[]): Tuple2[]; (a0: T0_2[], a1: T1_2[], a2: T2_1[]): Tuple3[]; (a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4[]; (...arrays: any[][]): any[][]; } >a0 : T0[] >a1 : T1[] >a2 : T2[] @@ -3863,7 +3863,7 @@ module Underscore { >propertyName : string sortedIndex(list: T[], obj: T, iterator?: Iterator_, context?: any): number; ->sortedIndex : { (list: T_1[], obj: T_1, propertyName: string): number; (list: T[], obj: T, iterator?: Iterator_, context?: any): number; } +>sortedIndex : { (list: T_1[], obj: T_1, propertyName: string): number; (list: T[], obj: T, iterator?: Iterator_, context?: any): number; } >list : T[] >obj : T >iterator : Iterator_ diff --git a/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.types b/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.types index 21c45aa7c33fd..55af55a808723 100644 --- a/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.types +++ b/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.types @@ -18,6 +18,6 @@ class C { }; let l = () => { }; ->l : () => void ->() => { } : () => void +>l : () => void +>() => { } : () => void diff --git a/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.types b/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.types index 4dcbe8e82e0fe..e21a6f2b7f3f0 100644 --- a/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.types +++ b/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.types @@ -18,6 +18,6 @@ class C { }; let l = () => { }; ->l : () => void ->() => { } : () => void +>l : () => void +>() => { } : () => void diff --git a/tests/baselines/reference/variableDeclaratorResolvedDuringContextualTyping.types b/tests/baselines/reference/variableDeclaratorResolvedDuringContextualTyping.types index a5863bebec99e..fcb1942c1b5f7 100644 --- a/tests/baselines/reference/variableDeclaratorResolvedDuringContextualTyping.types +++ b/tests/baselines/reference/variableDeclaratorResolvedDuringContextualTyping.types @@ -105,7 +105,7 @@ module WinJS { >progress : ProgressCallback public then(success?: (value: V) => TPromise, error?: (err: any) => U, progress?: ProgressCallback): TPromise; ->then : { (success?: (value: V) => TPromise, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => TPromise, error?: (err: any) => U, progress?: ProgressCallback): TPromise; (success?: (value: V) => U_3, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => U_4, error?: (err: any) => U_4, progress?: ProgressCallback): TPromise; } +>then : { (success?: (value: V) => TPromise, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => TPromise, error?: (err: any) => U, progress?: ProgressCallback): TPromise; (success?: (value: V) => U_2, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => U_3, error?: (err: any) => U_3, progress?: ProgressCallback): TPromise; } >success : (value: V) => TPromise >value : V >error : (err: any) => U @@ -113,7 +113,7 @@ module WinJS { >progress : ProgressCallback public then(success?: (value: V) => U, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; ->then : { (success?: (value: V) => TPromise, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => TPromise, error?: (err: any) => U_2, progress?: ProgressCallback): TPromise; (success?: (value: V) => U, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => U_4, error?: (err: any) => U_4, progress?: ProgressCallback): TPromise; } +>then : { (success?: (value: V) => TPromise, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => TPromise, error?: (err: any) => U_2, progress?: ProgressCallback): TPromise; (success?: (value: V) => U, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => U_3, error?: (err: any) => U_3, progress?: ProgressCallback): TPromise; } >success : (value: V) => U >value : V >error : (err: any) => TPromise @@ -121,7 +121,7 @@ module WinJS { >progress : ProgressCallback public then(success?: (value: V) => U, error?: (err: any) => U, progress?: ProgressCallback): TPromise; ->then : { (success?: (value: V) => TPromise, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => TPromise, error?: (err: any) => U_2, progress?: ProgressCallback): TPromise; (success?: (value: V) => U_3, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => U, error?: (err: any) => U, progress?: ProgressCallback): TPromise; } +>then : { (success?: (value: V) => TPromise, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => TPromise, error?: (err: any) => U_2, progress?: ProgressCallback): TPromise; (success?: (value: V) => U_3, error?: (err: any) => TPromise, progress?: ProgressCallback): TPromise; (success?: (value: V) => U, error?: (err: any) => U, progress?: ProgressCallback): TPromise; } >success : (value: V) => U >value : V >error : (err: any) => U diff --git a/tests/baselines/reference/variadicTuples1.types b/tests/baselines/reference/variadicTuples1.types index 73a28336eb9a7..fac1b78db51fc 100644 --- a/tests/baselines/reference/variadicTuples1.types +++ b/tests/baselines/reference/variadicTuples1.types @@ -1328,7 +1328,7 @@ declare function f22(args: [...T, number]): T; >args : [...T, number] declare function f22(args: [...T]): T; ->f22 : { (args: [...T_1, number]): T_1; (args: [...T]): T; } +>f22 : { (args: [...T_1, number]): T_1; (args: [...T]): T; } >args : [...T] function f23(args: [...U, number]) { From 4abb74771923fbd06b08560d5b5eedb23b4f7d15 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 6 Nov 2023 15:23:02 -0800 Subject: [PATCH 6/6] Empty commit to retrigger CI