From 458e87824b0f415e48e74a3792a2399af091881a Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 15 Feb 2017 08:40:23 -0800 Subject: [PATCH 01/35] ES5:Emit parameter initialiser before object rest destructuring Fix #14026, where ES5 emit for a parameter with 1. a default value initialiser 2. an object binding pattern containing an object rest incorrectly emitted the destructuring for the object rest before the default value initialisation. This happened because, during emit, the ES next transform runs first, transforming object rest destructuring and marking it as part of the function prologue. Then the ES5 transform runs and transforms the default initialiser, also marking it as part of the prologue. Then the prologue is emitted in the order the statements were added. The fix is to not mark the object rest destructuring as part of the prologue. I'm not 100% sure that this is the right fix, but it fixes the bug as it stands today. Here's an example: ```ts function foobar({ bar={}, ...opts }: any = {}) { } ``` which should have the ES5 emit: ```js function foobar(_a) { if (_a === void 0) { _a = {}; } var _b = _a.bar, bar = _b === void 0 ? {} : _b, opts = __rest(_a, ["bar"]); } ``` --- src/compiler/transformers/esnext.ts | 1 - .../reference/objectRestParameter.js | 12 +- .../reference/objectRestParameter.symbols | 15 +++ .../reference/objectRestParameter.types | 25 +++++ .../reference/objectRestParameterES5.js | 69 ++++++++++++ .../reference/objectRestParameterES5.symbols | 83 ++++++++++++++ .../reference/objectRestParameterES5.types | 104 ++++++++++++++++++ .../types/rest/objectRestParameter.ts | 6 +- .../types/rest/objectRestParameterES5.ts | 21 ++++ 9 files changed, 333 insertions(+), 3 deletions(-) create mode 100644 tests/baselines/reference/objectRestParameterES5.js create mode 100644 tests/baselines/reference/objectRestParameterES5.symbols create mode 100644 tests/baselines/reference/objectRestParameterES5.types create mode 100644 tests/cases/conformance/types/rest/objectRestParameterES5.ts diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index f058e627df7..c413415380d 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -375,7 +375,6 @@ namespace ts { declarations ) ); - setEmitFlags(statement, EmitFlags.CustomPrologue); leadingStatements = append(leadingStatements, statement); } } diff --git a/tests/baselines/reference/objectRestParameter.js b/tests/baselines/reference/objectRestParameter.js index 14e84eddfce..a73e9b77b38 100644 --- a/tests/baselines/reference/objectRestParameter.js +++ b/tests/baselines/reference/objectRestParameter.js @@ -14,7 +14,11 @@ class C { // actually, never mind, don't clone } } - +function foobar({ bar={}, ...opts }: any = {}) { +} +foobar(); +foobar({ baz: 'hello' }); +foobar({ bar: { greeting: 'hello' } }); //// [objectRestParameter.js] @@ -48,3 +52,9 @@ class C { // actually, never mind, don't clone } } +function foobar(_a = {}) { + var { bar = {} } = _a, opts = __rest(_a, ["bar"]); +} +foobar(); +foobar({ baz: 'hello' }); +foobar({ bar: { greeting: 'hello' } }); diff --git a/tests/baselines/reference/objectRestParameter.symbols b/tests/baselines/reference/objectRestParameter.symbols index c43a8ba5a04..f629f46e8e9 100644 --- a/tests/baselines/reference/objectRestParameter.symbols +++ b/tests/baselines/reference/objectRestParameter.symbols @@ -64,5 +64,20 @@ class C { // actually, never mind, don't clone } } +function foobar({ bar={}, ...opts }: any = {}) { +>foobar : Symbol(foobar, Decl(objectRestParameter.ts, 14, 1)) +>bar : Symbol(bar, Decl(objectRestParameter.ts, 15, 17)) +>opts : Symbol(opts, Decl(objectRestParameter.ts, 15, 25)) +} +foobar(); +>foobar : Symbol(foobar, Decl(objectRestParameter.ts, 14, 1)) +foobar({ baz: 'hello' }); +>foobar : Symbol(foobar, Decl(objectRestParameter.ts, 14, 1)) +>baz : Symbol(baz, Decl(objectRestParameter.ts, 18, 8)) + +foobar({ bar: { greeting: 'hello' } }); +>foobar : Symbol(foobar, Decl(objectRestParameter.ts, 14, 1)) +>bar : Symbol(bar, Decl(objectRestParameter.ts, 19, 8)) +>greeting : Symbol(greeting, Decl(objectRestParameter.ts, 19, 15)) diff --git a/tests/baselines/reference/objectRestParameter.types b/tests/baselines/reference/objectRestParameter.types index 56e7352870f..e56e7cebfc7 100644 --- a/tests/baselines/reference/objectRestParameter.types +++ b/tests/baselines/reference/objectRestParameter.types @@ -75,5 +75,30 @@ class C { // actually, never mind, don't clone } } +function foobar({ bar={}, ...opts }: any = {}) { +>foobar : ({bar, ...opts}?: any) => void +>bar : {} +>{} : {} +>opts : any +>{} : {} +} +foobar(); +>foobar() : void +>foobar : ({bar, ...opts}?: any) => void +foobar({ baz: 'hello' }); +>foobar({ baz: 'hello' }) : void +>foobar : ({bar, ...opts}?: any) => void +>{ baz: 'hello' } : { baz: string; } +>baz : string +>'hello' : "hello" + +foobar({ bar: { greeting: 'hello' } }); +>foobar({ bar: { greeting: 'hello' } }) : void +>foobar : ({bar, ...opts}?: any) => void +>{ bar: { greeting: 'hello' } } : { bar: { greeting: string; }; } +>bar : { greeting: string; } +>{ greeting: 'hello' } : { greeting: string; } +>greeting : string +>'hello' : "hello" diff --git a/tests/baselines/reference/objectRestParameterES5.js b/tests/baselines/reference/objectRestParameterES5.js new file mode 100644 index 00000000000..d16a0c68df0 --- /dev/null +++ b/tests/baselines/reference/objectRestParameterES5.js @@ -0,0 +1,69 @@ +//// [objectRestParameterES5.ts] +function cloneAgain({ a, ...clone }: { a: number, b: string }): void { +} + +declare function suddenly(f: (a: { x: { z, ka }, y: string }) => void); +suddenly(({ x: a, ...rest }) => rest.y); +suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka); + +class C { + m({ a, ...clone }: { a: number, b: string}): void { + // actually, never mind, don't clone + } + set p({ a, ...clone }: { a: number, b: string}) { + // actually, never mind, don't clone + } +} +function foobar({ bar={}, ...opts }: any = {}) { +} +foobar(); +foobar({ baz: 'hello' }); +foobar({ bar: { greeting: 'hello' } }); + + +//// [objectRestParameterES5.js] +var __rest = (this && this.__rest) || function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0) + t[p[i]] = s[p[i]]; + return t; +}; +function cloneAgain(_a) { + var a = _a.a, clone = __rest(_a, ["a"]); +} +suddenly(function (_a) { + var a = _a.x, rest = __rest(_a, ["x"]); + return rest.y; +}); +suddenly(function (_a) { + if (_a === void 0) { _a = { x: { z: 1, ka: 1 }, y: 'noo' }; } + var _b = _a.x, _c = _b.z, z = _c === void 0 ? 12 : _c, nested = __rest(_b, ["z"]), rest = __rest(_a, ["x"]); + return rest.y + nested.ka; +}); +var C = (function () { + function C() { + } + C.prototype.m = function (_a) { + var a = _a.a, clone = __rest(_a, ["a"]); + // actually, never mind, don't clone + }; + Object.defineProperty(C.prototype, "p", { + set: function (_a) { + var a = _a.a, clone = __rest(_a, ["a"]); + // actually, never mind, don't clone + }, + enumerable: true, + configurable: true + }); + return C; +}()); +function foobar(_a) { + if (_a === void 0) { _a = {}; } + var _b = _a.bar, bar = _b === void 0 ? {} : _b, opts = __rest(_a, ["bar"]); +} +foobar(); +foobar({ baz: 'hello' }); +foobar({ bar: { greeting: 'hello' } }); diff --git a/tests/baselines/reference/objectRestParameterES5.symbols b/tests/baselines/reference/objectRestParameterES5.symbols new file mode 100644 index 00000000000..4c6b8115169 --- /dev/null +++ b/tests/baselines/reference/objectRestParameterES5.symbols @@ -0,0 +1,83 @@ +=== tests/cases/conformance/types/rest/objectRestParameterES5.ts === +function cloneAgain({ a, ...clone }: { a: number, b: string }): void { +>cloneAgain : Symbol(cloneAgain, Decl(objectRestParameterES5.ts, 0, 0)) +>a : Symbol(a, Decl(objectRestParameterES5.ts, 0, 21)) +>clone : Symbol(clone, Decl(objectRestParameterES5.ts, 0, 24)) +>a : Symbol(a, Decl(objectRestParameterES5.ts, 0, 38)) +>b : Symbol(b, Decl(objectRestParameterES5.ts, 0, 49)) +} + +declare function suddenly(f: (a: { x: { z, ka }, y: string }) => void); +>suddenly : Symbol(suddenly, Decl(objectRestParameterES5.ts, 1, 1)) +>f : Symbol(f, Decl(objectRestParameterES5.ts, 3, 26)) +>a : Symbol(a, Decl(objectRestParameterES5.ts, 3, 30)) +>x : Symbol(x, Decl(objectRestParameterES5.ts, 3, 34)) +>z : Symbol(z, Decl(objectRestParameterES5.ts, 3, 39)) +>ka : Symbol(ka, Decl(objectRestParameterES5.ts, 3, 42)) +>y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48)) + +suddenly(({ x: a, ...rest }) => rest.y); +>suddenly : Symbol(suddenly, Decl(objectRestParameterES5.ts, 1, 1)) +>x : Symbol(x, Decl(objectRestParameterES5.ts, 3, 34)) +>a : Symbol(a, Decl(objectRestParameterES5.ts, 4, 11)) +>rest : Symbol(rest, Decl(objectRestParameterES5.ts, 4, 17)) +>rest.y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48)) +>rest : Symbol(rest, Decl(objectRestParameterES5.ts, 4, 17)) +>y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48)) + +suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka); +>suddenly : Symbol(suddenly, Decl(objectRestParameterES5.ts, 1, 1)) +>x : Symbol(x, Decl(objectRestParameterES5.ts, 3, 34)) +>z : Symbol(z, Decl(objectRestParameterES5.ts, 5, 16)) +>nested : Symbol(nested, Decl(objectRestParameterES5.ts, 5, 24)) +>rest : Symbol(rest, Decl(objectRestParameterES5.ts, 5, 37)) +>x : Symbol(x, Decl(objectRestParameterES5.ts, 5, 51)) +>z : Symbol(z, Decl(objectRestParameterES5.ts, 5, 56)) +>ka : Symbol(ka, Decl(objectRestParameterES5.ts, 5, 62)) +>y : Symbol(y, Decl(objectRestParameterES5.ts, 5, 71)) +>rest.y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48)) +>rest : Symbol(rest, Decl(objectRestParameterES5.ts, 5, 37)) +>y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48)) +>nested.ka : Symbol(ka, Decl(objectRestParameterES5.ts, 3, 42)) +>nested : Symbol(nested, Decl(objectRestParameterES5.ts, 5, 24)) +>ka : Symbol(ka, Decl(objectRestParameterES5.ts, 3, 42)) + +class C { +>C : Symbol(C, Decl(objectRestParameterES5.ts, 5, 107)) + + m({ a, ...clone }: { a: number, b: string}): void { +>m : Symbol(C.m, Decl(objectRestParameterES5.ts, 7, 9)) +>a : Symbol(a, Decl(objectRestParameterES5.ts, 8, 7)) +>clone : Symbol(clone, Decl(objectRestParameterES5.ts, 8, 10)) +>a : Symbol(a, Decl(objectRestParameterES5.ts, 8, 24)) +>b : Symbol(b, Decl(objectRestParameterES5.ts, 8, 35)) + + // actually, never mind, don't clone + } + set p({ a, ...clone }: { a: number, b: string}) { +>p : Symbol(C.p, Decl(objectRestParameterES5.ts, 10, 5)) +>a : Symbol(a, Decl(objectRestParameterES5.ts, 11, 11)) +>clone : Symbol(clone, Decl(objectRestParameterES5.ts, 11, 14)) +>a : Symbol(a, Decl(objectRestParameterES5.ts, 11, 28)) +>b : Symbol(b, Decl(objectRestParameterES5.ts, 11, 39)) + + // actually, never mind, don't clone + } +} +function foobar({ bar={}, ...opts }: any = {}) { +>foobar : Symbol(foobar, Decl(objectRestParameterES5.ts, 14, 1)) +>bar : Symbol(bar, Decl(objectRestParameterES5.ts, 15, 17)) +>opts : Symbol(opts, Decl(objectRestParameterES5.ts, 15, 25)) +} +foobar(); +>foobar : Symbol(foobar, Decl(objectRestParameterES5.ts, 14, 1)) + +foobar({ baz: 'hello' }); +>foobar : Symbol(foobar, Decl(objectRestParameterES5.ts, 14, 1)) +>baz : Symbol(baz, Decl(objectRestParameterES5.ts, 18, 8)) + +foobar({ bar: { greeting: 'hello' } }); +>foobar : Symbol(foobar, Decl(objectRestParameterES5.ts, 14, 1)) +>bar : Symbol(bar, Decl(objectRestParameterES5.ts, 19, 8)) +>greeting : Symbol(greeting, Decl(objectRestParameterES5.ts, 19, 15)) + diff --git a/tests/baselines/reference/objectRestParameterES5.types b/tests/baselines/reference/objectRestParameterES5.types new file mode 100644 index 00000000000..009d810782b --- /dev/null +++ b/tests/baselines/reference/objectRestParameterES5.types @@ -0,0 +1,104 @@ +=== tests/cases/conformance/types/rest/objectRestParameterES5.ts === +function cloneAgain({ a, ...clone }: { a: number, b: string }): void { +>cloneAgain : ({a, ...clone}: { a: number; b: string; }) => void +>a : number +>clone : { b: string; } +>a : number +>b : string +} + +declare function suddenly(f: (a: { x: { z, ka }, y: string }) => void); +>suddenly : (f: (a: { x: { z: any; ka: any; }; y: string; }) => void) => any +>f : (a: { x: { z: any; ka: any; }; y: string; }) => void +>a : { x: { z: any; ka: any; }; y: string; } +>x : { z: any; ka: any; } +>z : any +>ka : any +>y : string + +suddenly(({ x: a, ...rest }) => rest.y); +>suddenly(({ x: a, ...rest }) => rest.y) : any +>suddenly : (f: (a: { x: { z: any; ka: any; }; y: string; }) => void) => any +>({ x: a, ...rest }) => rest.y : ({x: a, ...rest}: { x: { z: any; ka: any; }; y: string; }) => string +>x : any +>a : { z: any; ka: any; } +>rest : { y: string; } +>rest.y : string +>rest : { y: string; } +>y : string + +suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka); +>suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka) : any +>suddenly : (f: (a: { x: { z: any; ka: any; }; y: string; }) => void) => any +>({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka : ({x: {z, ...nested}, ...rest}?: { x: { z: any; ka: any; }; y: string; }) => string +>x : any +>z : any +>12 : 12 +>nested : { ka: any; } +>rest : { y: string; } +>{ x: { z: 1, ka: 1 }, y: 'noo' } : { x: { z: number; ka: number; }; y: string; } +>x : { z: number; ka: number; } +>{ z: 1, ka: 1 } : { z: number; ka: number; } +>z : number +>1 : 1 +>ka : number +>1 : 1 +>y : string +>'noo' : "noo" +>rest.y + nested.ka : string +>rest.y : string +>rest : { y: string; } +>y : string +>nested.ka : any +>nested : { ka: any; } +>ka : any + +class C { +>C : C + + m({ a, ...clone }: { a: number, b: string}): void { +>m : ({a, ...clone}: { a: number; b: string; }) => void +>a : number +>clone : { b: string; } +>a : number +>b : string + + // actually, never mind, don't clone + } + set p({ a, ...clone }: { a: number, b: string}) { +>p : { a: number; b: string; } +>a : number +>clone : { b: string; } +>a : number +>b : string + + // actually, never mind, don't clone + } +} +function foobar({ bar={}, ...opts }: any = {}) { +>foobar : ({bar, ...opts}?: any) => void +>bar : {} +>{} : {} +>opts : any +>{} : {} +} +foobar(); +>foobar() : void +>foobar : ({bar, ...opts}?: any) => void + +foobar({ baz: 'hello' }); +>foobar({ baz: 'hello' }) : void +>foobar : ({bar, ...opts}?: any) => void +>{ baz: 'hello' } : { baz: string; } +>baz : string +>'hello' : "hello" + +foobar({ bar: { greeting: 'hello' } }); +>foobar({ bar: { greeting: 'hello' } }) : void +>foobar : ({bar, ...opts}?: any) => void +>{ bar: { greeting: 'hello' } } : { bar: { greeting: string; }; } +>bar : { greeting: string; } +>{ greeting: 'hello' } : { greeting: string; } +>greeting : string +>'hello' : "hello" + diff --git a/tests/cases/conformance/types/rest/objectRestParameter.ts b/tests/cases/conformance/types/rest/objectRestParameter.ts index a9c17a29d14..5b6faeb7978 100644 --- a/tests/cases/conformance/types/rest/objectRestParameter.ts +++ b/tests/cases/conformance/types/rest/objectRestParameter.ts @@ -14,4 +14,8 @@ class C { // actually, never mind, don't clone } } - +function foobar({ bar={}, ...opts }: any = {}) { +} +foobar(); +foobar({ baz: 'hello' }); +foobar({ bar: { greeting: 'hello' } }); diff --git a/tests/cases/conformance/types/rest/objectRestParameterES5.ts b/tests/cases/conformance/types/rest/objectRestParameterES5.ts new file mode 100644 index 00000000000..07a15ffbd44 --- /dev/null +++ b/tests/cases/conformance/types/rest/objectRestParameterES5.ts @@ -0,0 +1,21 @@ +// @target: es5 +function cloneAgain({ a, ...clone }: { a: number, b: string }): void { +} + +declare function suddenly(f: (a: { x: { z, ka }, y: string }) => void); +suddenly(({ x: a, ...rest }) => rest.y); +suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka); + +class C { + m({ a, ...clone }: { a: number, b: string}): void { + // actually, never mind, don't clone + } + set p({ a, ...clone }: { a: number, b: string}) { + // actually, never mind, don't clone + } +} +function foobar({ bar={}, ...opts }: any = {}) { +} +foobar(); +foobar({ baz: 'hello' }); +foobar({ bar: { greeting: 'hello' } }); From 304864c626a7a3fe78ad4f167bef361aaae89744 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 15 Feb 2017 13:29:02 -0800 Subject: [PATCH 02/35] Change prologue generation order; object rest back in prologue --- src/compiler/factory.ts | 1 - src/compiler/transformers/es2015.ts | 21 +++++++++------------ src/compiler/transformers/esnext.ts | 1 + 3 files changed, 10 insertions(+), 13 deletions(-) diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts index d5d8482a0ba..5f94ae8931a 100644 --- a/src/compiler/factory.ts +++ b/src/compiler/factory.ts @@ -2599,7 +2599,6 @@ namespace ts { * @param visitor: Optional callback used to visit any custom prologue directives. */ export function addPrologueDirectives(target: Statement[], source: Statement[], ensureUseStrict?: boolean, visitor?: (node: Node) => VisitResult): number { - Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array"); let foundUseStrict = false; let statementOffset = 0; const numStatements = source.length; diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts index e0fd435a90d..8353e393aa4 100644 --- a/src/compiler/transformers/es2015.ts +++ b/src/compiler/transformers/es2015.ts @@ -507,8 +507,8 @@ namespace ts { const ancestorFacts = enterSubtree(HierarchyFacts.SourceFileExcludes, HierarchyFacts.SourceFileIncludes); const statements: Statement[] = []; startLexicalEnvironment(); - const statementOffset = addPrologueDirectives(statements, node.statements, /*ensureUseStrict*/ false, visitor); addCaptureThisForNodeIfNeeded(statements, node); + const statementOffset = addPrologueDirectives(statements, node.statements, /*ensureUseStrict*/ false, visitor); addRange(statements, visitNodes(node.statements, visitor, isStatement, statementOffset)); addRange(statements, endLexicalEnvironment()); exitSubtree(ancestorFacts, HierarchyFacts.None, HierarchyFacts.None); @@ -915,14 +915,14 @@ namespace ts { // The assumption is that no prior step in the pipeline has added any prologue directives. statementOffset = 0; } - else if (constructor) { - // Otherwise, try to emit all potential prologue directives first. - statementOffset = addPrologueDirectives(statements, constructor.body.statements, /*ensureUseStrict*/ false, visitor); - } if (constructor) { addDefaultValueAssignmentsIfNeeded(statements, constructor); addRestParameterIfNeeded(statements, constructor, hasSynthesizedSuper); + if (!hasSynthesizedSuper) { + // If no super call has been synthesized, try to emit all potential prologue directives. + statementOffset = addPrologueDirectives(statements, constructor.body.statements, /*ensureUseStrict*/ false, visitor); + } Debug.assert(statementOffset >= 0, "statementOffset not initialized correctly!"); } @@ -1806,15 +1806,8 @@ namespace ts { const statements: Statement[] = []; const body = node.body; - let statementOffset: number; resumeLexicalEnvironment(); - if (isBlock(body)) { - // ensureUseStrict is false because no new prologue-directive should be added. - // addPrologueDirectives will simply put already-existing directives at the beginning of the target statement-array - statementOffset = addPrologueDirectives(statements, body.statements, /*ensureUseStrict*/ false, visitor); - } - addCaptureThisForNodeIfNeeded(statements, node); addDefaultValueAssignmentsIfNeeded(statements, node); addRestParameterIfNeeded(statements, node, /*inConstructorWithSynthesizedSuper*/ false); @@ -1825,6 +1818,10 @@ namespace ts { } if (isBlock(body)) { + // ensureUseStrict is false because no new prologue-directive should be added. + // addPrologueDirectives will simply put already-existing directives at the beginning of the target statement-array + const statementOffset = addPrologueDirectives(statements, body.statements, /*ensureUseStrict*/ false, visitor); + statementsLocation = body.statements; addRange(statements, visitNodes(body.statements, visitor, isStatement, statementOffset)); diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index c413415380d..f058e627df7 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -375,6 +375,7 @@ namespace ts { declarations ) ); + setEmitFlags(statement, EmitFlags.CustomPrologue); leadingStatements = append(leadingStatements, statement); } } From 42a832ad3d13d151f91d1a098b6dcc4c5dd68381 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Thu, 26 Jan 2017 11:02:08 -0800 Subject: [PATCH 03/35] Refactor findAllReferences. Now supports renamed exports and imports. --- Gulpfile.ts | 1 + src/compiler/checker.ts | 94 +- src/compiler/core.ts | 8 +- src/compiler/parser.ts | 1 + src/compiler/types.ts | 14 +- src/compiler/utilities.ts | 2 +- src/harness/fourslash.ts | 142 +- src/services/documentHighlights.ts | 36 +- src/services/findAllReferences.ts | 1169 ++++++++++------- src/services/goToImplementation.ts | 27 - src/services/importTracker.ts | 527 ++++++++ src/services/rename.ts | 8 +- src/services/services.ts | 42 +- src/services/tsconfig.json | 2 +- src/services/utilities.ts | 13 +- .../fourslash/ambientShorthandFindAllRefs.ts | 11 +- .../fourslash/ambientVariablesWithSameName.ts | 2 +- tests/cases/fourslash/cloduleAsBaseClass.ts | 2 +- tests/cases/fourslash/cloduleAsBaseClass2.ts | 2 +- tests/cases/fourslash/cloduleTypeOf1.ts | 2 +- .../cloduleWithRecursiveReference.ts | 2 +- .../completionListInImportClause04.ts | 4 +- ...letionListsThroughTransitiveBaseClasses.ts | 2 +- ...etionListsThroughTransitiveBaseClasses2.ts | 2 +- ...erivedTypeIndexerWithGenericConstraints.ts | 2 +- .../editLambdaArgToTypeParameter1.ts | 4 +- tests/cases/fourslash/enumUpdate1.ts | 4 +- ...ariableDeclOfMergedVariableAndClassDecl.ts | 5 +- tests/cases/fourslash/exportEqualTypes.ts | 2 +- .../fourslash/extendArrayInterfaceMember.ts | 2 +- .../extendInterfaceOverloadedMethod.ts | 2 +- tests/cases/fourslash/extendsTArray.ts | 2 +- .../findAllReferencesOfConstructor.ts | 14 +- ...indAllRefsDefaultImportThroughNamespace.ts | 20 + .../fourslash/findAllRefsExportAsNamespace.ts | 24 + .../fourslash/findAllRefsForDefaultExport.ts | 9 +- .../findAllRefsGlobalModuleAugmentation.ts | 13 + tests/cases/fourslash/findAllRefsIII.ts | 16 + .../findAllRefsImportStarOfExportEquals.ts | 60 + .../findAllRefsModuleAugmentation.ts | 13 + .../fourslash/findAllRefsOnDefinition2.ts | 1 - .../fourslash/findAllRefsOnImportAliases.ts | 12 +- .../fourslash/findAllRefsOnImportAliases2.ts | 21 +- .../fourslash/findAllRefsReExportLocal.ts | 30 + .../fourslash/findAllRefsReExportStar.ts | 18 + tests/cases/fourslash/findAllRefsReExports.ts | 61 + ...dAllRefsWithShorthandPropertyAssignment.ts | 2 +- .../fourslash/findReferencesJSXTagName.ts | 5 +- tests/cases/fourslash/fourslash.ts | 8 +- tests/cases/fourslash/functionTypes.ts | 2 +- .../funduleWithRecursiveReference.ts | 2 +- .../genericInterfacePropertyInference1.ts | 28 +- .../genericInterfacePropertyInference2.ts | 6 +- .../genericInterfaceWithInheritanceEdit1.ts | 6 +- tests/cases/fourslash/genericMapTyping1.ts | 2 +- tests/cases/fourslash/genericMethodParam.ts | 6 +- .../cases/fourslash/genericObjectBaseType.ts | 2 +- .../fourslash/genericRespecialization1.ts | 6 +- .../genericTypeArgumentInference1.ts | 2 +- .../genericTypeArgumentInference2.ts | 2 +- .../getOccurrencesIsDefinitionOfExport.ts | 7 +- .../getSemanticDiagnosticForDeclaration1.ts | 4 +- .../getSemanticDiagnosticForNoDeclaration.ts | 2 +- .../goToImplementationInterfaceMethod_00.ts | 2 +- ...alUpdateToClassImplementingGenericClass.ts | 4 +- tests/cases/fourslash/javaScriptClass2.ts | 13 +- tests/cases/fourslash/javascriptModules22.ts | 2 +- .../fourslash/jsDocFunctionSignatures4.ts | 3 +- tests/cases/fourslash/jsxSpreadReference.ts | 4 +- .../cases/fourslash/memberConstructorEdits.ts | 8 +- tests/cases/fourslash/memberOverloadEdits.ts | 4 +- tests/cases/fourslash/moduleReferenceValue.ts | 2 +- tests/cases/fourslash/multiModuleClodule1.ts | 2 +- tests/cases/fourslash/multiModuleFundule1.ts | 2 +- tests/cases/fourslash/parenthesisFatArrows.ts | 2 +- tests/cases/fourslash/quickInfoMeaning.ts | 3 +- ...oOnMergedInterfacesWithIncrementalEdits.ts | 2 +- .../fourslash/quickInfoOnMergedModule.ts | 2 +- .../cases/fourslash/referencesForAmbients2.ts | 21 + .../fourslash/renameAcrossMultipleProjects.ts | 7 +- .../fourslash/renameAliasExternalModule2.ts | 8 +- .../fourslash/renameCommentsAndStrings1.ts | 7 +- .../fourslash/renameCommentsAndStrings2.ts | 8 +- .../fourslash/renameCommentsAndStrings3.ts | 8 +- .../fourslash/renameCommentsAndStrings4.ts | 6 +- tests/cases/fourslash/renameCrossJsTs01.ts | 5 +- tests/cases/fourslash/renameCrossJsTs02.ts | 12 - tests/cases/fourslash/renameDefaultImport.ts | 19 +- .../renameDefaultImportDifferentName.ts | 18 +- .../renameDestructuringAssignmentInFor.ts | 28 +- .../renameDestructuringAssignmentInForOf.ts | 22 +- ...ructuringAssignmentNestedInArrayLiteral.ts | 22 +- ...enameDestructuringAssignmentNestedInFor.ts | 18 +- ...ameDestructuringAssignmentNestedInForOf.ts | 18 +- .../fourslash/renameForDefaultExport01.ts | 11 +- .../fourslash/renameForDefaultExport02.ts | 5 +- .../fourslash/renameForDefaultExport03.ts | 5 +- .../renameImportAndExportInDiffFiles.ts | 9 +- .../fourslash/renameImportOfExportEquals.ts | 35 +- .../fourslash/renameImportOfExportEquals2.ts | 36 + .../cases/fourslash/renameImportOfReExport.ts | 27 + .../fourslash/renameImportOfReExport2.ts | 28 + tests/cases/fourslash/renameJsExports01.ts | 4 +- tests/cases/fourslash/renameJsExports02.ts | 12 - .../fourslash/renameJsPrototypeProperty01.ts | 5 +- .../fourslash/renameJsPrototypeProperty02.ts | 5 +- .../cases/fourslash/renameJsThisProperty01.ts | 5 +- .../cases/fourslash/renameJsThisProperty02.ts | 12 - .../cases/fourslash/renameJsThisProperty03.ts | 5 +- .../cases/fourslash/renameJsThisProperty04.ts | 14 - tests/cases/fourslash/renameModuleToVar.ts | 2 +- tests/cases/fourslash/renameObjectSpread.ts | 12 +- .../fourslash/renameObjectSpreadAssignment.ts | 17 +- ...yNames.ts => renameStringPropertyNames.ts} | 0 tests/cases/fourslash/renameThis.ts | 13 +- .../server/jsdocTypedefTagRename01.ts | 14 +- .../server/jsdocTypedefTagRename02.ts | 10 +- .../server/jsdocTypedefTagRename03.ts | 7 +- tests/cases/fourslash/server/rename01.ts | 8 +- .../server/renameInConfiguredProject.ts | 5 +- .../cases/fourslash/shims-pp/getRenameInfo.ts | 9 +- tests/cases/fourslash/shims/getRenameInfo.ts | 9 +- .../superInDerivedTypeOfGenericWithStatics.ts | 4 +- .../fourslash/transitiveExportImports.ts | 31 +- .../fourslash/transitiveExportImports2.ts | 30 + .../fourslash/transitiveExportImports3.ts | 25 + tests/cases/fourslash/tsxRename1.ts | 5 +- tests/cases/fourslash/tsxRename2.ts | 5 +- tests/cases/fourslash/tsxRename3.ts | 9 +- tests/cases/fourslash/tsxRename4.ts | 9 +- tests/cases/fourslash/tsxRename5.ts | 7 +- 131 files changed, 2241 insertions(+), 1032 deletions(-) delete mode 100644 src/services/goToImplementation.ts create mode 100644 src/services/importTracker.ts create mode 100644 tests/cases/fourslash/findAllRefsDefaultImportThroughNamespace.ts create mode 100644 tests/cases/fourslash/findAllRefsExportAsNamespace.ts create mode 100644 tests/cases/fourslash/findAllRefsGlobalModuleAugmentation.ts create mode 100644 tests/cases/fourslash/findAllRefsIII.ts create mode 100644 tests/cases/fourslash/findAllRefsImportStarOfExportEquals.ts create mode 100644 tests/cases/fourslash/findAllRefsModuleAugmentation.ts create mode 100644 tests/cases/fourslash/findAllRefsReExportLocal.ts create mode 100644 tests/cases/fourslash/findAllRefsReExportStar.ts create mode 100644 tests/cases/fourslash/findAllRefsReExports.ts create mode 100644 tests/cases/fourslash/referencesForAmbients2.ts delete mode 100644 tests/cases/fourslash/renameCrossJsTs02.ts create mode 100644 tests/cases/fourslash/renameImportOfExportEquals2.ts create mode 100644 tests/cases/fourslash/renameImportOfReExport.ts create mode 100644 tests/cases/fourslash/renameImportOfReExport2.ts delete mode 100644 tests/cases/fourslash/renameJsExports02.ts delete mode 100644 tests/cases/fourslash/renameJsThisProperty02.ts delete mode 100644 tests/cases/fourslash/renameJsThisProperty04.ts rename tests/cases/fourslash/{renameStingPropertyNames.ts => renameStringPropertyNames.ts} (100%) create mode 100644 tests/cases/fourslash/transitiveExportImports2.ts create mode 100644 tests/cases/fourslash/transitiveExportImports3.ts diff --git a/Gulpfile.ts b/Gulpfile.ts index 4f205bfb0ff..2f243b9c39c 100644 --- a/Gulpfile.ts +++ b/Gulpfile.ts @@ -44,6 +44,7 @@ const cmdLineOptions = minimist(process.argv.slice(2), { boolean: ["debug", "light", "colors", "lint", "soft"], string: ["browser", "tests", "host", "reporter", "stackTraceLimit"], alias: { + b: "browser", d: "debug", t: "tests", test: "tests", diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 11f3fb99380..30e7d34f174 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -72,6 +72,7 @@ namespace ts { isUndefinedSymbol: symbol => symbol === undefinedSymbol, isArgumentsSymbol: symbol => symbol === argumentsSymbol, isUnknownSymbol: symbol => symbol === unknownSymbol, + getMergedSymbol, getDiagnostics, getGlobalDiagnostics, getTypeOfSymbolAtLocation, @@ -106,6 +107,7 @@ namespace ts { isValidPropertyAccess, getSignatureFromDeclaration, isImplementationOfOverload, + getImmediateAliasedSymbol, getAliasedSymbol: resolveAlias, getEmitResolver, getExportsOfModule: getExportsOfModuleAsArray, @@ -1161,14 +1163,14 @@ namespace ts { return find(symbol.declarations, isAliasSymbolDeclaration); } - function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration): Symbol { + function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration, dontResolveAlias: boolean): Symbol { if (node.moduleReference.kind === SyntaxKind.ExternalModuleReference) { return resolveExternalModuleSymbol(resolveExternalModuleName(node, getExternalModuleImportEqualsDeclarationExpression(node))); } - return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference); + return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, dontResolveAlias); } - function getTargetOfImportClause(node: ImportClause): Symbol { + function getTargetOfImportClause(node: ImportClause, dontResolveAlias: boolean): Symbol { const moduleSymbol = resolveExternalModuleName(node, (node.parent).moduleSpecifier); if (moduleSymbol) { @@ -1180,22 +1182,22 @@ namespace ts { const exportValue = moduleSymbol.exports.get("export="); exportDefaultSymbol = exportValue ? getPropertyOfType(getTypeOfSymbol(exportValue), "default") - : resolveSymbol(moduleSymbol.exports.get("default")); + : resolveSymbol(moduleSymbol.exports.get("default"), dontResolveAlias); } if (!exportDefaultSymbol && !allowSyntheticDefaultImports) { error(node.name, Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol)); } else if (!exportDefaultSymbol && allowSyntheticDefaultImports) { - return resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol); + return resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias); } return exportDefaultSymbol; } } - function getTargetOfNamespaceImport(node: NamespaceImport): Symbol { + function getTargetOfNamespaceImport(node: NamespaceImport, dontResolveAlias: boolean): Symbol { const moduleSpecifier = (node.parent.parent).moduleSpecifier; - return resolveESModuleSymbol(resolveExternalModuleName(node, moduleSpecifier), moduleSpecifier); + return resolveESModuleSymbol(resolveExternalModuleName(node, moduleSpecifier), moduleSpecifier, dontResolveAlias); } // This function creates a synthetic symbol that combines the value side of one symbol with the @@ -1229,12 +1231,9 @@ namespace ts { return result; } - function getExportOfModule(symbol: Symbol, name: string): Symbol { + function getExportOfModule(symbol: Symbol, name: string, dontResolveAlias: boolean): Symbol { if (symbol.flags & SymbolFlags.Module) { - const exportedSymbol = getExportsOfSymbol(symbol).get(name); - if (exportedSymbol) { - return resolveSymbol(exportedSymbol); - } + return resolveSymbol(getExportsOfSymbol(symbol).get(name), dontResolveAlias); } } @@ -1247,9 +1246,9 @@ namespace ts { } } - function getExternalModuleMember(node: ImportDeclaration | ExportDeclaration, specifier: ImportOrExportSpecifier): Symbol { + function getExternalModuleMember(node: ImportDeclaration | ExportDeclaration, specifier: ImportOrExportSpecifier, dontResolveAlias?: boolean): Symbol { const moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier); - const targetSymbol = resolveESModuleSymbol(moduleSymbol, node.moduleSpecifier); + const targetSymbol = resolveESModuleSymbol(moduleSymbol, node.moduleSpecifier, dontResolveAlias); if (targetSymbol) { const name = specifier.propertyName || specifier.name; if (name.text) { @@ -1266,11 +1265,11 @@ namespace ts { symbolFromVariable = getPropertyOfVariable(targetSymbol, name.text); } // if symbolFromVariable is export - get its final target - symbolFromVariable = resolveSymbol(symbolFromVariable); - let symbolFromModule = getExportOfModule(targetSymbol, name.text); + symbolFromVariable = resolveSymbol(symbolFromVariable, dontResolveAlias); + let symbolFromModule = getExportOfModule(targetSymbol, name.text, dontResolveAlias); // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default if (!symbolFromModule && allowSyntheticDefaultImports && name.text === "default") { - symbolFromModule = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol); + symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias); } const symbol = symbolFromModule && symbolFromVariable ? combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) : @@ -1283,45 +1282,58 @@ namespace ts { } } - function getTargetOfImportSpecifier(node: ImportSpecifier): Symbol { - return getExternalModuleMember(node.parent.parent.parent, node); + function getTargetOfImportSpecifier(node: ImportSpecifier, dontResolveAlias: boolean): Symbol { + return getExternalModuleMember(node.parent.parent.parent, node, dontResolveAlias); } - function getTargetOfNamespaceExportDeclaration(node: NamespaceExportDeclaration): Symbol { - return resolveExternalModuleSymbol(node.parent.symbol); + function getTargetOfNamespaceExportDeclaration(node: NamespaceExportDeclaration, dontResolveAlias: boolean): Symbol { + return resolveExternalModuleSymbol(node.parent.symbol, dontResolveAlias); } - function getTargetOfExportSpecifier(node: ExportSpecifier): Symbol { + function getTargetOfExportSpecifier(node: ExportSpecifier, dontResolveAlias?: boolean): Symbol { return (node.parent.parent).moduleSpecifier ? - getExternalModuleMember(node.parent.parent, node) : - resolveEntityName(node.propertyName || node.name, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace); + getExternalModuleMember(node.parent.parent, node, dontResolveAlias) : + resolveEntityName(node.propertyName || node.name, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace, /*ignoreErrors*/false, dontResolveAlias); } - function getTargetOfExportAssignment(node: ExportAssignment): Symbol { - return resolveEntityName(node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace); + function getTargetOfExportAssignment(node: ExportAssignment, dontResolveAlias: boolean): Symbol { + return resolveEntityName(node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace, /*ignoreErrors*/false, dontResolveAlias); } - function getTargetOfAliasDeclaration(node: Declaration): Symbol { + function getTargetOfAliasDeclaration(node: Declaration, dontRecursivelyResolve?: boolean): Symbol { switch (node.kind) { case SyntaxKind.ImportEqualsDeclaration: - return getTargetOfImportEqualsDeclaration(node); + return getTargetOfImportEqualsDeclaration(node, dontRecursivelyResolve); case SyntaxKind.ImportClause: - return getTargetOfImportClause(node); + return getTargetOfImportClause(node, dontRecursivelyResolve); case SyntaxKind.NamespaceImport: - return getTargetOfNamespaceImport(node); + return getTargetOfNamespaceImport(node, dontRecursivelyResolve); case SyntaxKind.ImportSpecifier: - return getTargetOfImportSpecifier(node); + return getTargetOfImportSpecifier(node, dontRecursivelyResolve); case SyntaxKind.ExportSpecifier: - return getTargetOfExportSpecifier(node); + return getTargetOfExportSpecifier(node, dontRecursivelyResolve); case SyntaxKind.ExportAssignment: - return getTargetOfExportAssignment(node); + return getTargetOfExportAssignment(node, dontRecursivelyResolve); case SyntaxKind.NamespaceExportDeclaration: - return getTargetOfNamespaceExportDeclaration(node); + return getTargetOfNamespaceExportDeclaration(node, dontRecursivelyResolve); } } - function resolveSymbol(symbol: Symbol): Symbol { - return symbol && symbol.flags & SymbolFlags.Alias && !(symbol.flags & (SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace)) ? resolveAlias(symbol) : symbol; + function resolveSymbol(symbol: Symbol, dontResolveAlias?: boolean): Symbol { + const shouldResolve = !dontResolveAlias && symbol && symbol.flags & SymbolFlags.Alias && !(symbol.flags & (SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace)); + return shouldResolve ? resolveAlias(symbol) : symbol; + } + + function getImmediateAliasedSymbol(symbol: Symbol): Symbol { + Debug.assert((symbol.flags & SymbolFlags.Alias) !== 0, "Should only get Alias here."); + const links = getSymbolLinks(symbol); + if (!links.immediateTarget) { + const node = getDeclarationOfAliasSymbol(symbol); + Debug.assert(!!node); + links.immediateTarget = getTargetOfAliasDeclaration(node, /*dontRecursivelyResolve*/true); + } + + return links.immediateTarget; } function resolveAlias(symbol: Symbol): Symbol { @@ -1538,16 +1550,16 @@ namespace ts { // An external module with an 'export =' declaration resolves to the target of the 'export =' declaration, // and an external module with no 'export =' declaration resolves to the module itself. - function resolveExternalModuleSymbol(moduleSymbol: Symbol): Symbol { - return moduleSymbol && getMergedSymbol(resolveSymbol(moduleSymbol.exports.get("export="))) || moduleSymbol; + function resolveExternalModuleSymbol(moduleSymbol: Symbol, dontResolveAlias?: boolean): Symbol { + return moduleSymbol && getMergedSymbol(resolveSymbol(moduleSymbol.exports.get("export="), dontResolveAlias)) || moduleSymbol; } // An external module with an 'export =' declaration may be referenced as an ES6 module provided the 'export =' // references a symbol that is at least declared as a module or a variable. The target of the 'export =' may // combine other declarations with the module or variable (e.g. a class/module, function/module, interface/variable). - function resolveESModuleSymbol(moduleSymbol: Symbol, moduleReferenceExpression: Expression): Symbol { - let symbol = resolveExternalModuleSymbol(moduleSymbol); - if (symbol && !(symbol.flags & (SymbolFlags.Module | SymbolFlags.Variable))) { + function resolveESModuleSymbol(moduleSymbol: Symbol, moduleReferenceExpression: Expression, dontResolveAlias: boolean): Symbol { + let symbol = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias); + if (!dontResolveAlias && symbol && !(symbol.flags & (SymbolFlags.Module | SymbolFlags.Variable))) { error(moduleReferenceExpression, Diagnostics.Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct, symbolToString(moduleSymbol)); symbol = undefined; } diff --git a/src/compiler/core.ts b/src/compiler/core.ts index 71c0f55c9af..be4f315e3ee 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -887,10 +887,12 @@ namespace ts { } /** Shims `Array.from`. */ - export function arrayFrom(iterator: Iterator): T[] { - const result: T[] = []; + export function arrayFrom(iterator: Iterator, map: (t: T) => U): U[]; + export function arrayFrom(iterator: Iterator): T[]; + export function arrayFrom(iterator: Iterator, map?: (t: any) => any): any[] { + const result: any[] = []; for (let { value, done } = iterator.next(); !done; { value, done } = iterator.next()) { - result.push(value); + result.push(map ? map(value) : value); } return result; } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index ebd4208832c..73708eb08f3 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -457,6 +457,7 @@ namespace ts { return Parser.parseIsolatedEntityName(text, languageVersion); } + // See also `isExternalOrCommonJsModule` in utilities.ts export function isExternalModule(file: SourceFile): boolean { return file.externalModuleIndicator !== undefined; } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 6a07eb688be..83b9dd9dbd7 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1818,6 +1818,7 @@ } export interface ExternalModuleReference extends Node { + parent: ImportEqualsDeclaration; kind: SyntaxKind.ExternalModuleReference; expression?: Expression; } @@ -1829,6 +1830,7 @@ export interface ImportDeclaration extends Statement { kind: SyntaxKind.ImportDeclaration; importClause?: ImportClause; + /** If this is not a StringLiteral it will be a grammar error. */ moduleSpecifier: Expression; } @@ -1860,6 +1862,7 @@ export interface ExportDeclaration extends DeclarationStatement { kind: SyntaxKind.ExportDeclaration; exportClause?: NamedExports; + /** If this is not a StringLiteral it will be a grammar error. */ moduleSpecifier?: Expression; } @@ -1869,6 +1872,7 @@ } export interface NamedExports extends Node { + parent: ExportDeclaration; kind: SyntaxKind.NamedExports; elements: NodeArray; } @@ -1882,6 +1886,7 @@ } export interface ExportSpecifier extends Declaration { + parent: NamedExports; kind: SyntaxKind.ExportSpecifier; propertyName?: Identifier; // Name preceding "as" keyword (or undefined when "as" is absent) name: Identifier; // Declared name @@ -2219,8 +2224,8 @@ // Content of this field should never be used directly - use getResolvedModuleFileName/setResolvedModuleFileName functions instead /* @internal */ resolvedModules: Map; /* @internal */ resolvedTypeReferenceDirectiveNames: Map; - /* @internal */ imports: LiteralExpression[]; - /* @internal */ moduleAugmentations: LiteralExpression[]; + /* @internal */ imports: StringLiteral[]; + /* @internal */ moduleAugmentations: StringLiteral[]; /* @internal */ patternAmbientModules?: PatternAmbientModule[]; /* @internal */ ambientModuleNames: string[]; } @@ -2418,10 +2423,14 @@ isUndefinedSymbol(symbol: Symbol): boolean; isArgumentsSymbol(symbol: Symbol): boolean; isUnknownSymbol(symbol: Symbol): boolean; + /* @internal */ getMergedSymbol(symbol: Symbol): Symbol; getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number; isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean; + /** Follow all aliases to get the original symbol. */ getAliasedSymbol(symbol: Symbol): Symbol; + /** Follow a *single* alias to get the immediately aliased symbol. */ + /* @internal */ getImmediateAliasedSymbol(symbol: Symbol): Symbol; getExportsOfModule(moduleSymbol: Symbol): Symbol[]; /** Unlike `getExportsOfModule`, this includes properties of an `export =` value. */ /* @internal */ getExportsAndPropertiesOfModule(moduleSymbol: Symbol): Symbol[]; @@ -2728,6 +2737,7 @@ /* @internal */ export interface SymbolLinks { + immediateTarget?: Symbol; // Immediate target of an alias. May be another alias. Do not access directly, use `checker.getImmediateAliasedSymbol` instead. target?: Symbol; // Resolved (non-alias) target of an alias type?: Type; // Type of value symbol declaredType?: Type; // Type of class, interface, enum, type alias, or type parameter diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 917bfc5b111..6b0dec04f50 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -3103,7 +3103,7 @@ namespace ts { return isExportDefaultSymbol(symbol) ? symbol.valueDeclaration.localSymbol : undefined; } - export function isExportDefaultSymbol(symbol: Symbol): boolean { + function isExportDefaultSymbol(symbol: Symbol): boolean { return symbol && symbol.valueDeclaration && hasModifier(symbol.valueDeclaration, ModifierFlags.Default); } diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index 34aa9580d6d..b78546602d3 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -545,10 +545,21 @@ namespace FourSlash { Harness.IO.log("Unexpected error(s) found. Error list is:"); } - errors.forEach(function (error: ts.Diagnostic) { - Harness.IO.log(" minChar: " + error.start + - ", limChar: " + (error.start + error.length) + - ", message: " + ts.flattenDiagnosticMessageText(error.messageText, Harness.IO.newLine()) + "\n"); + for (const { start, length, messageText } of errors) { + Harness.IO.log(" minChar: " + start + + ", limChar: " + (start + length) + + ", message: " + ts.flattenDiagnosticMessageText(messageText, Harness.IO.newLine()) + "\n"); + } + } + + public verifyNoErrors() { + ts.forEachKey(this.inputFiles, fileName => { + const errors = this.getDiagnostics(fileName); + if (errors.length) { + this.printErrorLog(/*expectErrors*/ false, errors); + const error = errors[0] + this.raiseError(`Found an error: ${error.file.fileName}@${error.start}: ${error.messageText}`); + } }); } @@ -870,7 +881,68 @@ namespace FourSlash { } } - public verifyReferencesAre(expectedReferences: Range[]) { + /** Use `getProgram` instead of accessing this directly. */ + private _program: ts.Program; + /** Use `getChecker` instead of accessing this directly. */ + private _checker: ts.TypeChecker; + + private getProgram(): ts.Program { + return this._program || (this._program = this.languageService.getProgram()); + } + + private getChecker() { + return this._checker || (this._checker = this.getProgram().getTypeChecker()); + } + + private getSourceFile(): ts.SourceFile { + const { fileName } = this.activeFile; + const result = this.getProgram().getSourceFile(fileName); + if (!result) { + throw new Error(`Could not get source file ${fileName}`); + } + return result; + } + + private getNode(): ts.Node { + return ts.getTouchingPropertyName(this.getSourceFile(), this.currentCaretPosition); + } + + private goToAndGetNode(range: Range): ts.Node { + this.goToRangeStart(range); + const node = this.getNode(); + this.verifyRange("touching property name", range, node); + return node; + } + + private verifyRange(desc: string, expected: Range, actual: ts.Node) { + const actualStart = actual.getStart(); + const actualEnd = actual.getEnd(); + if (actualStart !== expected.start || actualEnd !== expected.end) { + this.raiseError(`${desc} should be ${expected.start}-${expected.end}, got ${actualStart}-${actualEnd}`); + } + } + + private verifySymbol(symbol: ts.Symbol, declarationRanges: Range[]) { + const { declarations } = symbol; + if (declarations.length !== declarationRanges.length) { + this.raiseError(`Expected to get ${declarationRanges.length} declarations, got ${declarations.length}`); + } + + ts.zipWith(declarations, declarationRanges, (decl, range) => { + this.verifyRange("symbol declaration", range, decl); + }); + } + + public verifySymbolAtLocation(startRange: Range, declarationRanges: Range[]): void { + const node = this.goToAndGetNode(startRange); + const symbol = this.getChecker().getSymbolAtLocation(node); + if (!symbol) { + this.raiseError("Could not get symbol at location"); + } + this.verifySymbol(symbol, declarationRanges); + } + + private verifyReferencesAre(expectedReferences: Range[]) { const actualReferences = this.getReferencesAtCaret() || []; if (actualReferences.length > expectedReferences.length) { @@ -1086,9 +1158,32 @@ namespace FourSlash { assert.equal(TestState.getDisplayPartsJson(actualQuickInfo.documentation), TestState.getDisplayPartsJson(documentation), this.messageAtLastKnownMarker("QuickInfo documentation")); } - public verifyRenameLocations(findInStrings: boolean, findInComments: boolean, ranges?: Range[]) { - const renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition); - if (renameInfo.canRename) { + public verifyRangesAreRenameLocations(options?: Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges?: Range[] }) { + const ranges = ts.isArray(options) ? options : options && options.ranges || this.getRanges(); + this.verifyRenameLocations(ranges, { ranges, ...options }); + } + + public verifyRenameLocations(startRanges: Range | Range[], options: Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges: Range[] }) { + let findInStrings: boolean, findInComments: boolean, ranges: Range[]; + if (ts.isArray(options)) { + findInStrings = findInComments = false; + ranges = options + } + else { + findInStrings = !!options.findInStrings; + findInComments = !!options.findInComments; + ranges = options.ranges; + } + + for (const startRange of toArray(startRanges)) { + this.goToRangeStart(startRange); + + const renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition); + if (!renameInfo.canRename) { + this.raiseError("Expected rename to succeed, but it actually failed."); + break; + } + let references = this.languageService.findRenameLocations( this.activeFile.fileName, this.currentCaretPosition, findInStrings, findInComments); @@ -1110,13 +1205,10 @@ namespace FourSlash { ts.zipWith(references, ranges, (reference, range) => { if (reference.textSpan.start !== range.start || ts.textSpanEnd(reference.textSpan) !== range.end) { - this.raiseError("Rename location results do not match.\n\nExpected: " + stringify(ranges) + "\n\nActual:" + JSON.stringify(references)); + this.raiseError("Rename location results do not match.\n\nExpected: " + stringify(ranges) + "\n\nActual:" + stringify(references)); } }); } - else { - this.raiseError("Expected rename to succeed, but it actually failed."); - } } public verifyQuickInfoExists(negative: boolean) { @@ -2484,8 +2576,8 @@ namespace FourSlash { } } - public verifyRangesAreRenameLocations(findInStrings: boolean, findInComments: boolean) { - this.goToEachRange(() => this.verifyRenameLocations(findInStrings, findInComments)); + public verifyRangesWithSameTextAreRenameLocations() { + this.rangesByText().forEach(ranges => this.verifyRangesAreRenameLocations(ranges)); } public verifyRangesWithSameTextAreDocumentHighlights() { @@ -2524,7 +2616,7 @@ namespace FourSlash { ts.zipWith(expectedRangesInFile, spansInFile, (expectedRange, span) => { if (span.textSpan.start !== expectedRange.start || ts.textSpanEnd(span.textSpan) !== expectedRange.end) { - this.raiseError(`verifyDocumentHighlights failed - span does not match, actual: ${JSON.stringify(span.textSpan)}, expected: ${expectedRange.start}--${expectedRange.end}`); + this.raiseError(`verifyDocumentHighlights failed - span does not match, actual: ${stringify(span.textSpan)}, expected: ${expectedRange.start}--${expectedRange.end}`); } }); } @@ -3423,8 +3515,8 @@ namespace FourSlashInterface { this.state.verifyGetEmitOutputContentsForCurrentFile(expected); } - public referencesAre(ranges: FourSlash.Range[]) { - this.state.verifyReferencesAre(ranges); + public symbolAtLocation(startRange: FourSlash.Range, ...declarationRanges: FourSlash.Range[]) { + this.state.verifySymbolAtLocation(startRange, declarationRanges); } public referencesOf(start: FourSlash.Range, references: FourSlash.Range[]) { @@ -3487,6 +3579,10 @@ namespace FourSlashInterface { this.state.verifyCurrentSignatureHelpIs(expected); } + public noErrors() { + this.state.verifyNoErrors(); + } + public numberOfErrorsInCurrentFile(expected: number) { this.state.verifyNumberOfErrorsInCurrentFile(expected); } @@ -3583,8 +3679,12 @@ namespace FourSlashInterface { this.state.verifyRangesAreOccurrences(isWriteAccess); } - public rangesAreRenameLocations(findInStrings = false, findInComments = false) { - this.state.verifyRangesAreRenameLocations(findInStrings, findInComments); + public rangesWithSameTextAreRenameLocations() { + this.state.verifyRangesWithSameTextAreRenameLocations(); + } + + public rangesAreRenameLocations(options?: FourSlash.Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges?: FourSlash.Range[] }) { + this.state.verifyRangesAreRenameLocations(options); } public rangesAreDocumentHighlights(ranges?: FourSlash.Range[]) { @@ -3621,8 +3721,8 @@ namespace FourSlashInterface { this.state.verifyRenameInfoFailed(message); } - public renameLocations(findInStrings: boolean, findInComments: boolean, ranges?: FourSlash.Range[]) { - this.state.verifyRenameLocations(findInStrings, findInComments, ranges); + public renameLocations(startRanges: FourSlash.Range | FourSlash.Range[], options: FourSlash.Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges: FourSlash.Range[] }) { + this.state.verifyRenameLocations(startRanges, options); } public verifyQuickInfoDisplayParts(kind: string, kindModifiers: string, textSpan: { start: number; length: number; }, diff --git a/src/services/documentHighlights.ts b/src/services/documentHighlights.ts index ff2b819ec26..fcf7d0848d1 100644 --- a/src/services/documentHighlights.ts +++ b/src/services/documentHighlights.ts @@ -17,32 +17,26 @@ namespace ts.DocumentHighlights { } function getSemanticDocumentHighlights(node: Node, typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFilesToSearch: SourceFile[]): DocumentHighlights[] { - const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFilesToSearch); - return referencedSymbols && convertReferencedSymbols(referencedSymbols); + const referenceEntries = FindAllReferences.getReferenceEntriesForNode(node, sourceFilesToSearch, typeChecker, cancellationToken); + return referenceEntries && convertReferencedSymbols(referenceEntries); } - function convertReferencedSymbols(referencedSymbols: ReferencedSymbol[]): DocumentHighlights[] { - const fileNameToDocumentHighlights = createMap(); - const result: DocumentHighlights[] = []; - for (const referencedSymbol of referencedSymbols) { - for (const referenceEntry of referencedSymbol.references) { - const fileName = referenceEntry.fileName; - let documentHighlights = fileNameToDocumentHighlights.get(fileName); - if (!documentHighlights) { - documentHighlights = { fileName, highlightSpans: [] }; - - fileNameToDocumentHighlights.set(fileName, documentHighlights); - result.push(documentHighlights); - } - - documentHighlights.highlightSpans.push({ - textSpan: referenceEntry.textSpan, - kind: referenceEntry.isWriteAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference - }); + function convertReferencedSymbols(referenceEntries: ReferenceEntry[]): DocumentHighlights[] { + const fileNameToDocumentHighlights = createMap(); + for (const referenceEntry of referenceEntries) { + const fileName = referenceEntry.fileName; + let highlightSpans = fileNameToDocumentHighlights.get(fileName); + if (!highlightSpans) { + fileNameToDocumentHighlights.set(fileName, highlightSpans = []); } + + highlightSpans.push({ + textSpan: referenceEntry.textSpan, + kind: referenceEntry.isWriteAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference + }); } - return result; + return arrayFrom(fileNameToDocumentHighlights.entries(), ([fileName, highlightSpans ]) => ({ fileName, highlightSpans })); } function getSyntacticDocumentHighlights(node: Node, sourceFile: SourceFile): DocumentHighlights[] { diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index 111ea98417d..c48aa6d2316 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -1,92 +1,103 @@ -/* @internal */ +/// + +/* @internal */ namespace ts.FindAllReferences { - export function findReferencedSymbols(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, findInStrings: boolean, findInComments: boolean, isForRename: boolean): ReferencedSymbol[] | undefined { - const node = getTouchingPropertyName(sourceFile, position, /*includeJsDocComment*/ true); - return getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFiles, findInStrings, findInComments, isForRename); + export interface Options { + readonly findInStrings?: boolean; + readonly findInComments?: boolean; + /** + * True if we are renaming the symbol. + * If so, we will find fewer references -- if it is referenced by several different names, we sill only find references for the original name. + */ + readonly isForRename?: boolean; + /** True if we are searching for implementations. We will have a different method of adding references if so. */ + readonly implementations?: boolean; } - export function convertReferences(referenceSymbols: ReferencedSymbol[]): ReferenceEntry[] { + export function findReferencedSymbols(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number): ReferencedSymbol[] | undefined { + const referencedSymbols = findAllReferencedSymbols(checker, cancellationToken, sourceFiles, sourceFile, position); + // Only include referenced symbols that have a valid definition. + return filter(referencedSymbols, rs => !!rs.definition); + } + + export function getImplementationsAtPosition(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number): ImplementationLocation[] { + const node = getTouchingPropertyName(sourceFile, position); + const referenceEntries = getImplementationReferenceEntries(checker, cancellationToken, sourceFiles, node); + return map(referenceEntries, ({ textSpan, fileName }) => ({ textSpan, fileName })); + } + + function getImplementationReferenceEntries(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], node: Node): ReferenceEntry[] { + // If invoked directly on a shorthand property assignment, then return + // the declaration of the symbol being assigned (not the symbol being assigned to). + if (node.parent.kind === SyntaxKind.ShorthandPropertyAssignment) { + const result: ReferenceEntry[] = []; + getReferenceEntriesForShorthandPropertyAssignment(node, typeChecker, node => result.push(getReferenceEntryFromNode(node))); + return result; + } + else if (node.kind === SyntaxKind.SuperKeyword || isSuperProperty(node.parent)) { + // References to and accesses on the super keyword only have one possible implementation, so no + // need to "Find all References" + const symbol = typeChecker.getSymbolAtLocation(node); + return symbol.valueDeclaration && [getReferenceEntryFromNode(symbol.valueDeclaration)]; + } + else { + // Perform "Find all References" and retrieve only those that are implementations + return getReferenceEntriesForNode(node, sourceFiles, typeChecker, cancellationToken, { implementations: true }); + } + } + + export function findReferencedEntries(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, options?: Options): ReferenceEntry[] | undefined { + return flattenEntries(findAllReferencedSymbols(checker, cancellationToken, sourceFiles, sourceFile, position, options)); + } + + function findAllReferencedSymbols(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, options?: Options): ReferencedSymbol[] | undefined { + const node = getTouchingPropertyName(sourceFile, position, /*includeJsDocComment*/ true); + return getReferencedSymbolsForNode(node, sourceFiles, checker, cancellationToken, options); + } + + export function getReferenceEntriesForNode(node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options = {}): ReferenceEntry[] | undefined { + return flattenEntries(getReferencedSymbolsForNode(node, sourceFiles, checker, cancellationToken, options)); + } + + function flattenEntries(referenceSymbols: ReferencedSymbol[]): ReferenceEntry[] { return referenceSymbols && flatMap(referenceSymbols, r => r.references); } - export function getReferencedSymbolsForNode(typeChecker: TypeChecker, cancellationToken: CancellationToken, node: Node, sourceFiles: SourceFile[], findInStrings?: boolean, findInComments?: boolean, isForRename?: boolean, implementations?: boolean): ReferencedSymbol[] | undefined { - if (!implementations) { - const special = getReferencedSymbolsSpecial(node, sourceFiles, typeChecker, cancellationToken); + /** Core find-all-references algorithm. Handles special cases before delegating to `getReferencedSymbolsForSymbol`. */ + function getReferencedSymbolsForNode(node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options = {}): ReferencedSymbol[] | undefined { + if (node.kind === ts.SyntaxKind.SourceFile) { + return undefined; + } + + if (!options.implementations) { + const special = getReferencedSymbolsSpecial(node, sourceFiles, checker, cancellationToken); if (special) { return special; } } - // `getSymbolAtLocation` normally returns the symbol of the class when given the constructor keyword, - // so we have to specify that we want the constructor symbol. - let symbol = typeChecker.getSymbolAtLocation(node); + const symbol = checker.getSymbolAtLocation(node); // Could not find a symbol e.g. unknown identifier if (!symbol) { - if (!implementations && node.kind === SyntaxKind.StringLiteral) { - return getReferencesForStringLiteral(node, sourceFiles, typeChecker, cancellationToken); + // String literal might be a property (and thus have a symbol), so do this here rather than in getReferencedSymbolsSpecial. + if (!options.implementations && node.kind === SyntaxKind.StringLiteral) { + return getReferencesForStringLiteral(node, sourceFiles, checker, cancellationToken); } // Can't have references to something that we have no symbol for. return undefined; } - const declarations = symbol.declarations; - // The symbol was an internal symbol and does not have a declaration e.g. undefined symbol - if (!declarations || !declarations.length) { + if (!symbol.declarations || !symbol.declarations.length) { return undefined; } - const { symbol: aliasedSymbol, shorthandModuleSymbol } = followAliases(symbol, node, typeChecker, isForRename); - symbol = aliasedSymbol; - - // Build the set of symbols to search for, initially it has only the current symbol - const searchSymbols = populateSearchSymbolSet(symbol, node, typeChecker, implementations); - if (shorthandModuleSymbol) { - searchSymbols.push(shorthandModuleSymbol); - } - - // Compute the meaning from the location and the symbol it references - const searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations); - - const result: ReferencedSymbol[] = []; - // Maps from a symbol ID to the ReferencedSymbol entry in 'result'. - const symbolToIndex: number[] = []; - const inheritsFromCache: Map = createMap(); - - // Get the text to search for. - // Note: if this is an external module symbol, the name doesn't include quotes. - const declaredName = stripQuotes(getDeclaredName(typeChecker, symbol, node)); - - // Try to get the smallest valid scope that we can limit our search to; - // otherwise we'll need to search globally (i.e. include each file). - const scope = getSymbolScope(symbol); - if (scope) { - getRefs(scope, declaredName); - } - else { - const isDefault = isExportDefaultSymbol(symbol); - const internedName = isDefault ? symbol.valueDeclaration.localSymbol.name : getInternedName(symbol, node); - for (const sourceFile of sourceFiles) { - cancellationToken.throwIfCancellationRequested(); - const searchName = (isDefault ? getDefaultImportName(symbol, sourceFile, typeChecker) : undefined) || - (sourceFileHasName(sourceFile, internedName) ? declaredName : undefined); - if (searchName !== undefined) { - getRefs(sourceFile, searchName); - } - } - } - - return result; - - function getRefs(scope: ts.Node, searchName: string): void { - getReferencesInNode(scope, symbol, searchName, node, searchMeaning, findInStrings, findInComments, result, - symbolToIndex, implementations, typeChecker, cancellationToken, searchSymbols, inheritsFromCache); - } + return getReferencedSymbolsForSymbol(symbol, node, sourceFiles, checker, cancellationToken, options); } /** getReferencedSymbols for special node kinds. */ - function getReferencedSymbolsSpecial(node: Node, sourceFiles: SourceFile[], typeChecker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] | undefined { + function getReferencedSymbolsSpecial(node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] | undefined { if (isTypeKeyword(node.kind)) { return getAllReferencesForKeyword(sourceFiles, node.kind, cancellationToken); } @@ -106,70 +117,261 @@ namespace ts.FindAllReferences { } if (isThis(node)) { - return getReferencesForThisKeyword(node, sourceFiles, typeChecker, cancellationToken); + return getReferencesForThisKeyword(node, sourceFiles, checker, cancellationToken); } if (node.kind === SyntaxKind.SuperKeyword) { - return getReferencesForSuperKeyword(node, typeChecker, cancellationToken); + return getReferencesForSuperKeyword(node, checker, cancellationToken); } return undefined; } - /** - * Follows aliases to get to the original declaration of a symbol. - * For a shorthand ambient module, we don't follow the alias to it, but we will need to add it to the set of search symbols. - */ - function followAliases(symbol: Symbol, node: Node, typeChecker: TypeChecker, isForRename: boolean): { symbol: Symbol, shorthandModuleSymbol?: Symbol } { - while (true) { - // When renaming a default import, only rename in the current file - if (isForRename && isImportDefaultSymbol(symbol)) { - return { symbol }; - } + /** Core find-all-references algorithm for a normal symbol. */ + function getReferencedSymbolsForSymbol(symbol: Symbol, node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options): ReferencedSymbol[] { + symbol = skipPastExportOrImportSpecifier(symbol, node, checker); - const aliasedSymbol = getAliasSymbolForPropertyNameSymbol(symbol, node, typeChecker); - // Don't follow alias if it goes to unknown symbol. This can happen if it points to an untyped module. - if (!aliasedSymbol || !aliasedSymbol.declarations) { - return { symbol }; - } + // Compute the meaning from the location and the symbol it references + const searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), symbol.declarations); - if (ts.isShorthandAmbientModuleSymbol(aliasedSymbol)) { - return { symbol, shorthandModuleSymbol: aliasedSymbol }; - } + const result: ReferencedSymbol[] = []; + const state = createState(sourceFiles, node, checker, cancellationToken, searchMeaning, options, result); + const search = state.createSearch(node, symbol, /*comingFrom*/undefined, { allSearchSymbols: populateSearchSymbolSet(symbol, node, checker, options.implementations) }); - symbol = aliasedSymbol; + // Try to get the smallest valid scope that we can limit our search to; + // otherwise we'll need to search globally (i.e. include each file). + const scope = getSymbolScope(symbol); + if (scope) { + getReferencesInContainer(scope, search, state); } + else { + // Global search + for (const sourceFile of state.sourceFiles) { + state.cancellationToken.throwIfCancellationRequested(); + searchForName(sourceFile, search, state); + } + } + + return result; } - function sourceFileHasName(sourceFile: SourceFile, name: string): boolean { - return getNameTable(sourceFile).get(name) !== undefined; + /** Handle a few special cases relating to export/import specifiers. */ + function skipPastExportOrImportSpecifier(symbol: Symbol, node: Node, checker: TypeChecker): Symbol { + const { parent } = node; + if (isExportSpecifier(parent)) { + return getLocalSymbolForExportSpecifier(node as Identifier, symbol, parent, checker); + } + if (isImportSpecifier(parent) && parent.propertyName === node) { + // We're at `foo` in `import { foo as bar }`. Probably intended to find all refs on the original, not just on the import. + return checker.getImmediateAliasedSymbol(symbol); + } + + return symbol; } /** - * Given a symbol, see if any of the imports in a source file reference it. - * Only call this if `symbol` is a default export. + * Symbol that is currently being searched for. + * This will be replaced if we find an alias for the symbol. */ - function getDefaultImportName(symbol: Symbol, sourceFile: SourceFile, checker: ts.TypeChecker): string | undefined { - for (const importSpecifier of sourceFile.imports) { - const importDecl = importSpecifier.parent as ts.ImportDeclaration; - Debug.assert(importDecl.moduleSpecifier === importSpecifier); - const defaultName = importDecl.importClause.name; - const defaultReferencedSymbol = checker.getAliasedSymbol(checker.getSymbolAtLocation(defaultName)); - if (symbol === defaultReferencedSymbol) { - return defaultName.text; - } - } - return undefined; + interface Search { + /** If coming from an export, we will not recursively search for the imported symbol (since that's where we came from). */ + readonly comingFrom?: ImportExport; + + readonly location: Node; + readonly symbol: Symbol; + readonly text: string; + readonly escapedText: string; + /** Only set if `options.implementations` is true. These are the symbols checked to get the implementations of a property access. */ + readonly parents: Symbol[] | undefined; + + /** + * Whether a symbol is in the search set. + * Do not compare directly to `symbol` because there may be related symbols to search for. See `populateSearchSymbolSet`. + */ + includes(symbol: Symbol): boolean; } - function getDefinition(symbol: Symbol, node: Node, typeChecker: TypeChecker): ReferencedSymbolDefinitionInfo { - const { displayParts, symbolKind } = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, node.getSourceFile(), getContainerNode(node), node); - const name = displayParts.map(p => p.text).join(""); + /** + * Holds all state needed for the finding references. + * Unlike `Search`, there is only one `State`. + */ + interface State extends Options { + /** True if we're searching for constructor references. */ + readonly isForConstructor: boolean; + + readonly sourceFiles: SourceFile[]; + readonly checker: TypeChecker; + readonly cancellationToken: CancellationToken; + readonly searchMeaning: SemanticMeaning; + + /** Cache for `explicitlyinheritsFrom`. */ + readonly inheritsFromCache: Map; + + /** Gets every place to look for references of an exported symbols. See `ImportsResult` in `importTracker.ts` for more documentation. */ + getImportSearches(exportSymbol: Symbol, exportInfo: ExportInfo): ImportsResult; + + /** @param allSearchSymbols set of additinal symbols for use by `includes`. */ + createSearch(location: Node, symbol: Symbol, comingFrom: ImportExport | undefined, searchOptions?: { text?: string, allSearchSymbols?: Symbol[] }): Search; + + /** + * Callback to add references for a particular searched symbol. + * This initializes a reference group, so only call this if you will add at least one reference. + */ + referenceAdder(searchSymbol: Symbol, searchLocation: Node): (node: Node) => void; + + /** Add a reference with no associated definition. */ + addStringOrCommentReference(fileName: string, textSpan: TextSpan): void; + + /** Returns `true` the first time we search for a symbol in a file and `false` afterwards. */ + markSearchedSymbol(sourceFile: SourceFile, symbol: Symbol): boolean; + + /** + * Type nodes can contain multiple references to the same type. For example: + * let x: Foo & (Foo & Bar) = ... + * Because we are returning the implementation locations and not the identifier locations, + * duplicate entries would be returned here as each of the type references is part of + * the same implementation. For that reason, check before we add a new entry. + */ + markSeenContainingTypeReference(containingTypeReference: Node): boolean; + + /** + * It's possible that we will encounter either side of `export { foo as bar } from "x";` more than once. + * For example: + * export { foo as bar } from "a"; + * import { foo } from "a"; + * + * Normally at `foo as bar` we directly add `foo` and do not locally search for it (since it doesn't declare a local). + * But another reference to it may appear in the same source file. + * See `tests/cases/fourslash/transitiveExportImports3.ts`. + */ + markSeenReExportLHS(lhs: Identifier): boolean; + markSeenReExportRHS(rhs: Identifier): boolean; + } + + function createState(sourceFiles: SourceFile[], originalLocation: Node, checker: TypeChecker, cancellationToken: CancellationToken, searchMeaning: SemanticMeaning, options: Options, result: Push): State { + const symbolIdToReferences: ReferenceEntry[][] = []; + const inheritsFromCache = createMap(); + // Source file ID → symbol ID → Whether the symbol has been searched for in the source file. + const sourceFileToSeenSymbols: Array> = []; + const isForConstructor = originalLocation.kind === SyntaxKind.ConstructorKeyword; + let importTracker: ImportTracker | undefined; + + return { + ...options, + sourceFiles, isForConstructor, checker, cancellationToken, searchMeaning, inheritsFromCache, getImportSearches, createSearch, referenceAdder, addStringOrCommentReference, + markSearchedSymbol, markSeenContainingTypeReference: nodeSeenTracker(), markSeenReExportLHS: nodeSeenTracker(), markSeenReExportRHS: nodeSeenTracker(), + }; + + function getImportSearches(exportSymbol: Symbol, exportInfo: ExportInfo): ImportsResult { + if (!importTracker) importTracker = createImportTracker(sourceFiles, checker); + return importTracker(exportSymbol, exportInfo, options.isForRename); + } + + function createSearch(location: Node, symbol: Symbol, comingFrom: ImportExport, searchOptions: { text?: string, allSearchSymbols?: Symbol[] } = {}): Search { + // Note: if this is an external module symbol, the name doesn't include quotes. + const { text = stripQuotes(getDeclaredName(checker, symbol, location)), allSearchSymbols = undefined } = searchOptions; + const escapedText = escapeIdentifier(text); + const parents = options.implementations && getParentSymbolsOfPropertyAccess(location, symbol, checker); + return { location, symbol, comingFrom, text, escapedText, parents, includes }; + + function includes(referenceSymbol: Symbol): boolean { + return allSearchSymbols ? contains(allSearchSymbols, referenceSymbol) : referenceSymbol === symbol; + } + } + + function referenceAdder(referenceSymbol: Symbol, searchLocation: Node): (node: Node) => void { + const symbolId = getSymbolId(referenceSymbol); + let references = symbolIdToReferences[symbolId]; + if (!references) { + references = symbolIdToReferences[symbolId] = []; + result.push({ definition: getDefinition(referenceSymbol, searchLocation, checker), references }); + } + return node => references.push(getReferenceEntryFromNode(node)); + } + + function addStringOrCommentReference(fileName: string, textSpan: TextSpan): void { + result.push({ + definition: undefined, + references: [{ fileName, textSpan, isWriteAccess: false, isDefinition: false }] + }); + } + + function markSearchedSymbol(sourceFile: SourceFile, symbol: Symbol): boolean { + const sourceId = getNodeId(sourceFile); + const symbolId = getSymbolId(symbol); + const seenSymbols = sourceFileToSeenSymbols[sourceId] || (sourceFileToSeenSymbols[sourceId] = []); + return !seenSymbols[symbolId] && (seenSymbols[symbolId] = true); + } + } + + /** Search for all imports of a given exported symbol using `State.getImportSearches`. */ + function searchForImportsOfExport(exportLocation: Node, exportSymbol: Symbol, exportInfo: ExportInfo, state: State): void { + const { importSearches, singleReferences, indirectUsers } = state.getImportSearches(exportSymbol, exportInfo); + + // For `import { foo as bar }` just add the reference to `foo`, and don't otherwise search in the file. + if (singleReferences.length) { + const addRef = state.referenceAdder(exportSymbol, exportLocation); + for (const singleRef of singleReferences) { + if (state.markSeenReExportLHS(singleRef)) { + addRef(singleRef); + } + } + } + + // For each import, find all references to that import in its source file. + for (const [importLocation, importSymbol] of importSearches) { + state.cancellationToken.throwIfCancellationRequested(); + getReferencesInContainer(importLocation.getSourceFile(), state.createSearch(importLocation, importSymbol, ImportExport.Export), state); + } + + if (indirectUsers.length) { + const indirectSearch = (() => { + switch (exportInfo.exportKind) { + case ExportKind.Named: + return state.createSearch(exportLocation, exportSymbol, ImportExport.Export); + case ExportKind.Default: + // Search for a property access to '.default'. This can't be renamed. + return state.isForRename ? undefined : state.createSearch(exportLocation, exportSymbol, ImportExport.Export, { text: "default" }); + case ExportKind.ExportEquals: + return undefined; + } + })(); + if (indirectSearch) { + for (const indirectUser of indirectUsers) { + state.cancellationToken.throwIfCancellationRequested(); + searchForName(indirectUser, indirectSearch, state); + } + } + } + } + + // Go to the symbol we imported from and find references for it. + function searchForImportedSymbol(symbol: Symbol, state: State): void { + for (const declaration of symbol.declarations) { + getReferencesInContainer(declaration.getSourceFile(), state.createSearch(declaration, symbol, ImportExport.Import), state); + } + } + + /** Search for all occurences of an identifier in a source file (and filter out the ones that match). */ + function searchForName(sourceFile: SourceFile, search: Search, state: State): void { + if (sourceFileHasName(sourceFile, search.escapedText)) { + getReferencesInContainer(sourceFile, search, state); + } + } + + function sourceFileHasName(sourceFile: SourceFile, escapedName: string): boolean { + return getNameTable(sourceFile).get(escapedName) !== undefined; + } + + function getDefinition(symbol: Symbol, node: Node, checker: TypeChecker): ReferencedSymbolDefinitionInfo | undefined { const declarations = symbol.declarations; if (!declarations || declarations.length === 0) { return undefined; } + const { displayParts, symbolKind } = + SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, node.getSourceFile(), getContainerNode(node), node); + const name = displayParts.map(p => p.text).join(""); return { containerKind: "", containerName: "", @@ -181,68 +383,27 @@ namespace ts.FindAllReferences { }; } - function getAliasSymbolForPropertyNameSymbol(symbol: Symbol, location: Node, typeChecker: TypeChecker): Symbol | undefined { - if (!(symbol.flags & SymbolFlags.Alias)) { - return undefined; - } - - // Default import get alias - const defaultImport = getDeclarationOfKind(symbol, SyntaxKind.ImportClause); - if (defaultImport) { - return typeChecker.getAliasedSymbol(symbol); - } - - const importOrExportSpecifier = forEach(symbol.declarations, - declaration => (declaration.kind === SyntaxKind.ImportSpecifier || - declaration.kind === SyntaxKind.ExportSpecifier) ? declaration : undefined); - if (importOrExportSpecifier && - // export { a } - (!importOrExportSpecifier.propertyName || - // export {a as class } where a is location - importOrExportSpecifier.propertyName === location)) { - // If Import specifier -> get alias - // else Export specifier -> get local target - return importOrExportSpecifier.kind === SyntaxKind.ImportSpecifier ? - typeChecker.getAliasedSymbol(symbol) : - typeChecker.getExportSpecifierLocalTargetSymbol(importOrExportSpecifier); - } - } - - function followAliasIfNecessary(symbol: Symbol, location: Node, typeChecker: TypeChecker): Symbol { - return getAliasSymbolForPropertyNameSymbol(symbol, location, typeChecker) || symbol; - } - - function getPropertySymbolOfDestructuringAssignment(location: Node, typeChecker: TypeChecker) { + function getPropertySymbolOfDestructuringAssignment(location: Node, checker: TypeChecker): Symbol | undefined { return isArrayLiteralOrObjectLiteralDestructuringPattern(location.parent.parent) && - typeChecker.getPropertySymbolOfDestructuringAssignment(location); + checker.getPropertySymbolOfDestructuringAssignment(location); } - function isObjectBindingPatternElementWithoutPropertyName(symbol: Symbol) { + function isObjectBindingPatternElementWithoutPropertyName(symbol: Symbol): boolean { const bindingElement = getDeclarationOfKind(symbol, SyntaxKind.BindingElement); return bindingElement && bindingElement.parent.kind === SyntaxKind.ObjectBindingPattern && !bindingElement.propertyName; } - function getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol: Symbol, typeChecker: TypeChecker) { + function getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol: Symbol, checker: TypeChecker): Symbol | undefined { if (isObjectBindingPatternElementWithoutPropertyName(symbol)) { const bindingElement = getDeclarationOfKind(symbol, SyntaxKind.BindingElement); - const typeOfPattern = typeChecker.getTypeAtLocation(bindingElement.parent); - return typeOfPattern && typeChecker.getPropertyOfType(typeOfPattern, (bindingElement.name).text); + const typeOfPattern = checker.getTypeAtLocation(bindingElement.parent); + return typeOfPattern && checker.getPropertyOfType(typeOfPattern, (bindingElement.name).text); } return undefined; } - function getInternedName(symbol: Symbol, location: Node): string { - // If this is an export or import specifier it could have been renamed using the 'as' syntax. - // If so we want to search for whatever under the cursor. - if (isImportOrExportSpecifierName(location)) { - return location.text; - } - - return stripQuotes(symbol.name); - } - /** * Determines the smallest scope in which a symbol may have named references. * Note that not every construct has been accounted for. This function can @@ -251,68 +412,66 @@ namespace ts.FindAllReferences { * @returns undefined if the scope cannot be determined, implying that * a reference to a symbol can occur anywhere. */ - function getSymbolScope(symbol: Symbol): Node { + function getSymbolScope(symbol: Symbol): Node | undefined { // If this is the symbol of a named function expression or named class expression, // then named references are limited to its own scope. - const valueDeclaration = symbol.valueDeclaration; + const { declarations, flags, parent, valueDeclaration } = symbol; if (valueDeclaration && (valueDeclaration.kind === SyntaxKind.FunctionExpression || valueDeclaration.kind === SyntaxKind.ClassExpression)) { return valueDeclaration; } + if (!declarations) { + return undefined; + } + // If this is private property or method, the scope is the containing class - if (symbol.flags & (SymbolFlags.Property | SymbolFlags.Method)) { - const privateDeclaration = forEach(symbol.getDeclarations(), d => (getModifierFlags(d) & ModifierFlags.Private) ? d : undefined); + if (flags & (SymbolFlags.Property | SymbolFlags.Method)) { + const privateDeclaration = find(declarations, d => !!(getModifierFlags(d) & ModifierFlags.Private)); if (privateDeclaration) { return getAncestor(privateDeclaration, SyntaxKind.ClassDeclaration); } } - // If the symbol is an import we would like to find it if we are looking for what it imports. - // So consider it visible outside its declaration scope. - if (symbol.flags & SymbolFlags.Alias) { - return undefined; - } - // If symbol is of object binding pattern element without property name we would want to // look for property too and that could be anywhere if (isObjectBindingPatternElementWithoutPropertyName(symbol)) { return undefined; } - // if this symbol is visible from its parent container, e.g. exported, then bail out - // if symbol correspond to the union property - bail out - if (symbol.parent || (symbol.flags & SymbolFlags.Transient && (symbol).checkFlags & CheckFlags.SyntheticProperty)) { + // The only symbols with parents *not* globally acessible are exports of external modules, and only then if they do not have `export as namespace`. + if (parent && !((parent.flags & SymbolFlags.Module) && isExternalModuleSymbol(parent) && !parent.globalExports)) { return undefined; } - let scope: Node; - - const declarations = symbol.getDeclarations(); - if (declarations) { - for (const declaration of declarations) { - const container = getContainerNode(declaration); - - if (!container) { - return undefined; - } - - if (scope && scope !== container) { - // Different declarations have different containers, bail out - return undefined; - } - - if (container.kind === SyntaxKind.SourceFile && !isExternalModule(container)) { - // This is a global variable and not an external module, any declaration defined - // within this scope is visible outside the file - return undefined; - } - - // The search scope is the container node - scope = container; - } + // If this is a synthetic property, it's a property and must be searched for globally. + if ((flags & SymbolFlags.Transient && (symbol).checkFlags & CheckFlags.SyntheticProperty)) { + return undefined; } - return scope; + let scope: Node | undefined; + for (const declaration of declarations) { + const container = getContainerNode(declaration); + if (scope && scope !== container) { + // Different declarations have different containers, bail out + return undefined; + } + + if (!container || container.kind === SyntaxKind.SourceFile && !isExternalOrCommonJsModule(container)) { + // This is a global variable and not an external module, any declaration defined + // within this scope is visible outside the file + return undefined; + } + + // The search scope is the container node + scope = container; + } + + // If symbol.parent, this means we are in an export of an external module. (Otherwise we would have returned `undefined` above.) + // For an export of a module, we may be in a declaration file, and it may be accessed elsewhere. E.g.: + // declare module "a" { export type T = number; } + // declare module "b" { import { T } from "a"; export const x: T; } + // So we must search the whole source file. (Because we will mark the source file as seen, we we won't return to it when searching for imports.) + return parent ? scope.getSourceFile() : scope; } function getPossibleSymbolReferencePositions(sourceFile: SourceFile, symbolName: string, start: number, end: number, cancellationToken: CancellationToken): number[] { @@ -357,12 +516,12 @@ namespace ts.FindAllReferences { const sourceFile = container.getSourceFile(); const labelName = targetLabel.text; const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, labelName, container.getStart(), container.getEnd(), cancellationToken); - forEach(possiblePositions, position => { + for (const position of possiblePositions) { cancellationToken.throwIfCancellationRequested(); const node = getTouchingWord(sourceFile, position); if (!node || node.getWidth() !== labelName.length) { - return; + continue; } // Only pick labels that are either the target label, or have a target that is the target label @@ -370,7 +529,7 @@ namespace ts.FindAllReferences { (isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel)) { references.push(getReferenceEntryFromNode(node)); } - }); + } const definition: ReferencedSymbolDefinitionInfo = { containerKind: "", @@ -422,7 +581,7 @@ namespace ts.FindAllReferences { name, textSpan: references[0].textSpan, displayParts: [{ text: name, kind: ScriptElementKind.keyword }] - } + }; return [{ definition, references }]; } @@ -443,161 +602,190 @@ namespace ts.FindAllReferences { } } - /** Search within node "container" for references for a search value, where the search value is defined as a - * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning). - * searchLocation: a node where the search value - */ - function getReferencesInNode(container: Node, - searchSymbol: Symbol, - searchText: string, - searchLocation: Node, - searchMeaning: SemanticMeaning, - findInStrings: boolean, - findInComments: boolean, - result: ReferencedSymbol[], - symbolToIndex: number[], - implementations: boolean, - typeChecker: TypeChecker, - cancellationToken: CancellationToken, - searchSymbols: Symbol[], - inheritsFromCache: Map): void { - + /** + * Search within node "container" for references for a search value, where the search value is defined as a + * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning). + * searchLocation: a node where the search value + */ + function getReferencesInContainer(container: Node, search: Search, state: State): void { const sourceFile = container.getSourceFile(); + if (!state.markSearchedSymbol(sourceFile, search.symbol)) { + return; + } - const start = findInComments ? container.getFullStart() : container.getStart(); - const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, start, container.getEnd(), cancellationToken); - - const parents = getParentSymbolsOfPropertyAccess(); - + const start = state.findInComments ? container.getFullStart() : container.getStart(); + const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, search.text, start, container.getEnd(), state.cancellationToken); for (const position of possiblePositions) { - cancellationToken.throwIfCancellationRequested(); + state.cancellationToken.throwIfCancellationRequested(); + getReferencesAtLocation(sourceFile, position, search, state); + } + } - const referenceLocation = getTouchingPropertyName(sourceFile, position); - if (!isValidReferencePosition(referenceLocation, searchText)) { - // This wasn't the start of a token. Check to see if it might be a - // match in a comment or string if that's what the caller is asking - // for. - if (!implementations && ((findInStrings && isInString(sourceFile, position)) || - (findInComments && isInNonReferenceComment(sourceFile, position)))) { + function getReferencesAtLocation(sourceFile: SourceFile, position: number, search: Search, state: State): void { + const referenceLocation = getTouchingPropertyName(sourceFile, position); - // In the case where we're looking inside comments/strings, we don't have - // an actual definition. So just use 'undefined' here. Features like - // 'Rename' won't care (as they ignore the definitions), and features like - // 'FindReferences' will just filter out these results. - result.push({ - definition: undefined, - references: [{ - fileName: sourceFile.fileName, - textSpan: createTextSpan(position, searchText.length), - isWriteAccess: false, - isDefinition: false - }] - }); - } - continue; + if (!isValidReferencePosition(referenceLocation, search.text)) { + // This wasn't the start of a token. Check to see if it might be a + // match in a comment or string if that's what the caller is asking + // for. + if (!state.implementations && (state.findInStrings && isInString(sourceFile, position) || state.findInComments && isInNonReferenceComment(sourceFile, position))) { + // In the case where we're looking inside comments/strings, we don't have + // an actual definition. So just use 'undefined' here. Features like + // 'Rename' won't care (as they ignore the definitions), and features like + // 'FindReferences' will just filter out these results. + state.addStringOrCommentReference(sourceFile.fileName, createTextSpan(position, search.text.length)); } - if (!(getMeaningFromLocation(referenceLocation) & searchMeaning)) { - continue; + return; + } + + if (!(getMeaningFromLocation(referenceLocation) & state.searchMeaning)) { + return; + } + + const referenceSymbol = state.checker.getSymbolAtLocation(referenceLocation); + if (!referenceSymbol) { + return; + } + + if (isExportSpecifier(referenceLocation.parent)) { + Debug.assert(referenceLocation.kind === SyntaxKind.Identifier); + getReferencesAtExportSpecifier(referenceLocation as Identifier, referenceSymbol, referenceLocation.parent, search, state); + return; + } + + const relatedSymbol = getRelatedSymbol(search, referenceSymbol, referenceLocation, state); + if (!relatedSymbol) { + getReferenceForShorthandProperty(referenceSymbol, search, state); + return; + } + + if (state.isForConstructor) { + findConstructorReferences(referenceLocation, sourceFile, search, state); + } + else { + addReference(referenceLocation, relatedSymbol, search.location, state); + } + + getImportOrExportReferences(referenceLocation, referenceSymbol, search, state); + } + + function getReferencesAtExportSpecifier(referenceLocation: Identifier, referenceSymbol: Symbol, exportSpecifier: ExportSpecifier, search: Search, state: State): void { + const { parent, propertyName, name } = exportSpecifier; + searchForExport(getLocalSymbolForExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, state.checker)); + + const exportDeclaration = parent.parent; + if (search.comingFrom !== ImportExport.Export && exportDeclaration.moduleSpecifier && !propertyName) { + searchForImportedSymbol(state.checker.getExportSpecifierLocalTargetSymbol(exportSpecifier), state); + } + + function searchForExport(localSymbol: Symbol): void { + if (!search.includes(localSymbol)) { + return; } - const referenceSymbol = typeChecker.getSymbolAtLocation(referenceLocation); - if (referenceSymbol) { - const referenceSymbolDeclaration = referenceSymbol.valueDeclaration; - const shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(referenceSymbolDeclaration); - const relatedSymbol = getRelatedSymbol(searchSymbols, referenceSymbol, referenceLocation, - /*searchLocationIsConstructor*/ searchLocation.kind === SyntaxKind.ConstructorKeyword, parents, inheritsFromCache, typeChecker); + if (!propertyName || (propertyName === referenceLocation ? state.markSeenReExportLHS : state.markSeenReExportRHS)(referenceLocation)) { + addReference(referenceLocation, localSymbol, search.location, state); + } - if (relatedSymbol) { - addReferenceToRelatedSymbol(referenceLocation, relatedSymbol); + const renameExportRHS = propertyName === referenceLocation ? name : undefined; + if (renameExportRHS) { + // For `export { foo as bar }`, rename `foo`, but not `bar`. + if (state.isForRename) { + return; } - /* Because in short-hand property assignment, an identifier which stored as name of the short-hand property assignment - * has two meanings: property name and property value. Therefore when we do findAllReference at the position where - * an identifier is declared, the language service should return the position of the variable declaration as well as - * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the - * position of property accessing, the referenceEntry of such position will be handled in the first case. - */ - else if (!(referenceSymbol.flags & SymbolFlags.Transient) && contains(searchSymbols, shorthandValueSymbol)) { - addReferenceToRelatedSymbol(referenceSymbolDeclaration.name, shorthandValueSymbol); - } - else if (searchLocation.kind === SyntaxKind.ConstructorKeyword) { - findAdditionalConstructorReferences(referenceSymbol, referenceLocation); + + if (state.markSeenReExportRHS(renameExportRHS)) { + addReference(renameExportRHS, referenceSymbol, renameExportRHS, state); } } + + const exportKind = (referenceLocation as Identifier).originalKeywordKind === ts.SyntaxKind.DefaultKeyword ? ExportKind.Default : ExportKind.Named; + const exportInfo = getExportInfo(referenceSymbol, exportKind, state.checker); + Debug.assert(!!exportInfo); + searchForImportsOfExport(referenceLocation, referenceSymbol, exportInfo, state); + } + } + + function getLocalSymbolForExportSpecifier(referenceLocation: Identifier, referenceSymbol: Symbol, exportSpecifier: ExportSpecifier, checker: TypeChecker): Symbol { + return isExportSpecifierAlias(referenceLocation, exportSpecifier) ? checker.getExportSpecifierLocalTargetSymbol(exportSpecifier) : referenceSymbol; + } + + function isExportSpecifierAlias(referenceLocation: Identifier, exportSpecifier: ExportSpecifier): boolean { + const { parent, propertyName, name } = exportSpecifier; + Debug.assert(propertyName === referenceLocation || name === referenceLocation); + if (propertyName) { + // Given `export { foo as bar } [from "someModule"]`: It's an alias at `foo`, but at `bar` it's a new symbol. + return propertyName === referenceLocation; + } + else { + // `export { foo } from "foo"` is a re-export. + // `export { foo };` is not a re-export, it creates an alias for the local variable `foo`. + return !parent.parent.moduleSpecifier; + } + } + + function getImportOrExportReferences(referenceLocation: Node, referenceSymbol: Symbol, search: Search, state: State): void { + const importOrExport = getImportOrExportSymbol(referenceLocation, referenceSymbol, state.checker, search.comingFrom === ImportExport.Export); + if (!importOrExport) return; + + const { symbol } = importOrExport; + + if (importOrExport.kind === ImportExport.Import) { + if (!state.isForRename || importOrExport.isNamedImport) { + searchForImportedSymbol(symbol, state); + } } - return; + else { + // We don't check for `state.isForRename`, even for default exports, because importers that previously matched the export name should be updated to continue matching. + searchForImportsOfExport(referenceLocation, symbol, importOrExport.exportInfo, state); + } + } - /* If we are just looking for implementations and this is a property access expression, we need to get the - * symbol of the local type of the symbol the property is being accessed on. This is because our search - * symbol may have a different parent symbol if the local type's symbol does not declare the property - * being accessed (i.e. it is declared in some parent class or interface) + function getReferenceForShorthandProperty({ flags, valueDeclaration }: Symbol, search: Search, state: State): void { + const shorthandValueSymbol = state.checker.getShorthandAssignmentValueSymbol(valueDeclaration); + /* + * Because in short-hand property assignment, an identifier which stored as name of the short-hand property assignment + * has two meanings: property name and property value. Therefore when we do findAllReference at the position where + * an identifier is declared, the language service should return the position of the variable declaration as well as + * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the + * position of property accessing, the referenceEntry of such position will be handled in the first case. */ - function getParentSymbolsOfPropertyAccess(): Symbol[] | undefined { - if (implementations) { - const propertyAccessExpression = getPropertyAccessExpressionFromRightHandSide(searchLocation); - if (propertyAccessExpression) { - const localParentType = typeChecker.getTypeAtLocation(propertyAccessExpression.expression); - if (localParentType) { - if (localParentType.symbol && localParentType.symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) && localParentType.symbol !== searchSymbol.parent) { - return [localParentType.symbol]; - } - else if (localParentType.flags & TypeFlags.UnionOrIntersection) { - return getSymbolsForClassAndInterfaceComponents(localParentType); - } - } - } - } + if (!(flags & SymbolFlags.Transient) && search.includes(shorthandValueSymbol)) { + addReference(valueDeclaration.name, shorthandValueSymbol, search.location, state); + } + } + + function addReference(referenceLocation: Node, relatedSymbol: Symbol, searchLocation: Node, state: State): void { + const addRef = state.referenceAdder(relatedSymbol, searchLocation); + if (state.implementations) { + addImplementationReferences(referenceLocation, addRef, state); + } + else { + addRef(referenceLocation); + } + } + + /** Adds references when a constructor is used with `new this()` in its own class and `super()` calls in subclasses. */ + function findConstructorReferences(referenceLocation: Node, sourceFile: SourceFile, search: Search, state: State): void { + if (isNewExpressionTarget(referenceLocation)) { + addReference(referenceLocation, search.symbol, search.location, state); } - /** Adds references when a constructor is used with `new this()` in its own class and `super()` calls in subclasses. */ - function findAdditionalConstructorReferences(referenceSymbol: Symbol, referenceLocation: Node): void { - Debug.assert(isClassLike(searchSymbol.valueDeclaration)); + const classSymbol = skipAliases(search.symbol, state.checker); + Debug.assert(isClassLike(classSymbol.valueDeclaration)); + const pusher = state.referenceAdder(search.symbol, search.location); - const referenceClass = referenceLocation.parent; - if (referenceSymbol === searchSymbol && isClassLike(referenceClass)) { - Debug.assert(referenceClass.name === referenceLocation); - // This is the class declaration containing the constructor. - addReferences(findOwnConstructorCalls(searchSymbol, sourceFile)); - } - else { - // If this class appears in `extends C`, then the extending class' "super" calls are references. - const classExtending = tryGetClassByExtendingIdentifier(referenceLocation); - if (classExtending && isClassLike(classExtending) && followAliasIfNecessary(referenceSymbol, referenceLocation, typeChecker) === searchSymbol) { - addReferences(superConstructorAccesses(classExtending)); - } - } + if (isClassLike(referenceLocation.parent)) { + Debug.assert(referenceLocation.parent.name === referenceLocation); + // This is the class declaration containing the constructor. + findOwnConstructorReferences(search.symbol, sourceFile, pusher); } - - function addReferences(references: Node[]): void { - if (references.length) { - const referencedSymbol = getReferencedSymbol(searchSymbol); - addRange(referencedSymbol.references, map(references, getReferenceEntryFromNode)); - } - } - - function getReferencedSymbol(symbol: Symbol): ReferencedSymbol { - const symbolId = getSymbolId(symbol); - let index = symbolToIndex[symbolId]; - if (index === undefined) { - index = result.length; - symbolToIndex[symbolId] = index; - - result.push({ - definition: getDefinition(symbol, searchLocation, typeChecker), - references: [] - }); - } - - return result[index]; - } - - function addReferenceToRelatedSymbol(node: Node, relatedSymbol: Symbol) { - const references = getReferencedSymbol(relatedSymbol).references; - if (implementations) { - getImplementationReferenceEntryForNode(node, references, typeChecker); - } - else { - references.push(getReferenceEntryFromNode(node)); + else { + // If this class appears in `extends C`, then the extending class' "super" calls are references. + const classExtending = tryGetClassByExtendingIdentifier(referenceLocation); + if (classExtending && isClassLike(classExtending)) { + findSuperConstructorAccesses(classExtending, pusher); } } } @@ -606,16 +794,15 @@ namespace ts.FindAllReferences { return isRightSideOfPropertyAccess(node) && node.parent; } - /** `classSymbol` is the class where the constructor was defined. + /** + * `classSymbol` is the class where the constructor was defined. * Reference the constructor and all calls to `new this()`. */ - function findOwnConstructorCalls(classSymbol: Symbol, sourceFile: SourceFile): Node[] { - const result: Node[] = []; - + function findOwnConstructorReferences(classSymbol: Symbol, sourceFile: SourceFile, addNode: (node: Node) => void): void { for (const decl of classSymbol.members.get("__constructor").declarations) { - const ctrKeyword = ts.findChildOfKind(decl, ts.SyntaxKind.ConstructorKeyword, sourceFile)! + const ctrKeyword = ts.findChildOfKind(decl, ts.SyntaxKind.ConstructorKeyword, sourceFile)!; Debug.assert(decl.kind === SyntaxKind.Constructor && !!ctrKeyword); - result.push(ctrKeyword); + addNode(ctrKeyword); } classSymbol.exports.forEach(member => { @@ -625,90 +812,79 @@ namespace ts.FindAllReferences { if (body) { forEachDescendantOfKind(body, SyntaxKind.ThisKeyword, thisKeyword => { if (isNewExpressionTarget(thisKeyword)) { - result.push(thisKeyword); + addNode(thisKeyword); } }); } } }); - - return result; } /** Find references to `super` in the constructor of an extending class. */ - function superConstructorAccesses(cls: ClassLikeDeclaration): Node[] { + function findSuperConstructorAccesses(cls: ClassLikeDeclaration, addNode: (node: Node) => void): void { const symbol = cls.symbol; const ctr = symbol.members.get("__constructor"); if (!ctr) { - return []; + return; } - const result: Node[] = []; for (const decl of ctr.declarations) { Debug.assert(decl.kind === SyntaxKind.Constructor); const body = (decl).body; if (body) { forEachDescendantOfKind(body, SyntaxKind.SuperKeyword, node => { if (isCallExpressionTarget(node)) { - result.push(node); + addNode(node); } }); } }; - return result; } - function getImplementationReferenceEntryForNode(refNode: Node, result: ReferenceEntry[], typeChecker: TypeChecker): void { + function addImplementationReferences(refNode: Node, addReference: (node: Node) => void, state: State): void { // Check if we found a function/propertyAssignment/method with an implementation or initializer if (isDeclarationName(refNode) && isImplementation(refNode.parent)) { - result.push(getReferenceEntryFromNode(refNode.parent)); - } - else if (refNode.kind === SyntaxKind.Identifier) { - if (refNode.parent.kind === SyntaxKind.ShorthandPropertyAssignment) { - // Go ahead and dereference the shorthand assignment by going to its definition - getReferenceEntriesForShorthandPropertyAssignment(refNode, typeChecker, result); - } - - // Check if the node is within an extends or implements clause - const containingClass = getContainingClassIfInHeritageClause(refNode); - if (containingClass) { - result.push(getReferenceEntryFromNode(containingClass)); - return; - } - - // If we got a type reference, try and see if the reference applies to any expressions that can implement an interface - const containingTypeReference = getContainingTypeReference(refNode); - if (containingTypeReference) { - const parent = containingTypeReference.parent; - if (isVariableLike(parent) && parent.type === containingTypeReference && parent.initializer && isImplementationExpression(parent.initializer)) { - maybeAdd(getReferenceEntryFromNode(parent.initializer)); - } - else if (isFunctionLike(parent) && parent.type === containingTypeReference && parent.body) { - if (parent.body.kind === SyntaxKind.Block) { - forEachReturnStatement(parent.body, returnStatement => { - if (returnStatement.expression && isImplementationExpression(returnStatement.expression)) { - maybeAdd(getReferenceEntryFromNode(returnStatement.expression)); - } - }); - } - else if (isImplementationExpression(parent.body)) { - maybeAdd(getReferenceEntryFromNode(parent.body)); - } - } - else if (isAssertionExpression(parent) && isImplementationExpression(parent.expression)) { - maybeAdd(getReferenceEntryFromNode(parent.expression)); - } - } + addReference(refNode.parent); + return; } - // Type nodes can contain multiple references to the same type. For example: - // let x: Foo & (Foo & Bar) = ... - // Because we are returning the implementation locations and not the identifier locations, - // duplicate entries would be returned here as each of the type references is part of - // the same implementation. For that reason, check before we add a new entry - function maybeAdd(a: ReferenceEntry) { - if (!forEach(result, b => a.fileName === b.fileName && a.textSpan.start === b.textSpan.start && a.textSpan.length === b.textSpan.length)) { - result.push(a); + if (refNode.kind !== SyntaxKind.Identifier) { + return; + } + + if (refNode.parent.kind === SyntaxKind.ShorthandPropertyAssignment) { + // Go ahead and dereference the shorthand assignment by going to its definition + getReferenceEntriesForShorthandPropertyAssignment(refNode, state.checker, addReference); + } + + // Check if the node is within an extends or implements clause + const containingClass = getContainingClassIfInHeritageClause(refNode); + if (containingClass) { + addReference(containingClass); + return; + } + + // If we got a type reference, try and see if the reference applies to any expressions that can implement an interface + const containingTypeReference = getContainingTypeReference(refNode); + if (containingTypeReference && state.markSeenContainingTypeReference(containingTypeReference)) { + const parent = containingTypeReference.parent; + if (isVariableLike(parent) && parent.type === containingTypeReference && parent.initializer && isImplementationExpression(parent.initializer)) { + addReference(parent.initializer); + } + else if (isFunctionLike(parent) && parent.type === containingTypeReference && parent.body) { + if (parent.body.kind === SyntaxKind.Block) { + forEachReturnStatement(parent.body, returnStatement => { + if (returnStatement.expression && isImplementationExpression(returnStatement.expression)) { + addReference(returnStatement.expression); + } + }); + } + else if (isImplementationExpression(parent.body)) { + addReference(parent.body); + } + } + else if (isAssertionExpression(parent) && isImplementationExpression(parent.expression)) { + addReference(parent.expression); } } } @@ -790,7 +966,7 @@ namespace ts.FindAllReferences { * @param parent Another class or interface Symbol * @param cachedResults A map of symbol id pairs (i.e. "child,parent") to booleans indicating previous results */ - function explicitlyInheritsFrom(child: Symbol, parent: Symbol, cachedResults: Map, typeChecker: TypeChecker): boolean { + function explicitlyInheritsFrom(child: Symbol, parent: Symbol, cachedResults: Map, checker: TypeChecker): boolean { const parentIsInterface = parent.getFlags() & SymbolFlags.Interface; return searchHierarchy(child); @@ -836,7 +1012,7 @@ namespace ts.FindAllReferences { function searchTypeReference(typeReference: ExpressionWithTypeArguments): boolean { if (typeReference) { - const type = typeChecker.getTypeAtLocation(typeReference); + const type = checker.getTypeAtLocation(typeReference); if (type && type.symbol) { return searchHierarchy(type.symbol); } @@ -845,7 +1021,7 @@ namespace ts.FindAllReferences { } } - function getReferencesForSuperKeyword(superKeyword: Node, typeChecker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] { + function getReferencesForSuperKeyword(superKeyword: Node, checker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] { let searchSpaceNode = getSuperContainer(superKeyword, /*stopOnFunctions*/ false); if (!searchSpaceNode) { return undefined; @@ -891,11 +1067,11 @@ namespace ts.FindAllReferences { } } - const definition = getDefinition(searchSpaceNode.symbol, superKeyword, typeChecker); + const definition = getDefinition(searchSpaceNode.symbol, superKeyword, checker); return [{ definition, references }]; } - function getReferencesForThisKeyword(thisOrSuperKeyword: Node, sourceFiles: SourceFile[], typeChecker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] { + function getReferencesForThisKeyword(thisOrSuperKeyword: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] { let searchSpaceNode = getThisContainer(thisOrSuperKeyword, /* includeArrowFunctions */ false); // Whether 'this' occurs in a static context within a class. @@ -945,10 +1121,10 @@ namespace ts.FindAllReferences { getThisReferencesInFile(sourceFile, searchSpaceNode, possiblePositions, references); } - const thisOrSuperSymbol = typeChecker.getSymbolAtLocation(thisOrSuperKeyword); + const thisOrSuperSymbol = checker.getSymbolAtLocation(thisOrSuperKeyword); const displayParts = thisOrSuperSymbol && SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind( - typeChecker, thisOrSuperSymbol, thisOrSuperKeyword.getSourceFile(), getContainerNode(thisOrSuperKeyword), thisOrSuperKeyword).displayParts; + checker, thisOrSuperSymbol, thisOrSuperKeyword.getSourceFile(), getContainerNode(thisOrSuperKeyword), thisOrSuperKeyword).displayParts; return [{ definition: { @@ -1005,8 +1181,8 @@ namespace ts.FindAllReferences { } } - function getReferencesForStringLiteral(node: StringLiteral, sourceFiles: SourceFile[], typeChecker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] { - const type = getStringLiteralTypeForNode(node, typeChecker); + function getReferencesForStringLiteral(node: StringLiteral, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] { + const type = getStringLiteralTypeForNode(node, checker); if (!type) { // nothing to do here. moving on @@ -1042,7 +1218,7 @@ namespace ts.FindAllReferences { return; } - const type = getStringLiteralTypeForNode(node, typeChecker); + const type = getStringLiteralTypeForNode(node, checker); if (type === searchType) { references.push(getReferenceEntryFromNode(node)); } @@ -1050,41 +1226,43 @@ namespace ts.FindAllReferences { } } - function populateSearchSymbolSet(symbol: Symbol, location: Node, typeChecker: TypeChecker, implementations: boolean): Symbol[] { + // For certain symbol kinds, we need to include other symbols in the search set. + // This is not needed when searching for re-exports. + function populateSearchSymbolSet(symbol: Symbol, location: Node, checker: TypeChecker, implementations: boolean): Symbol[] { // The search set contains at least the current symbol const result = [symbol]; - // If the location is name of property symbol from object literal destructuring pattern - // Search the property symbol - // for ( { property: p2 } of elems) { } const containingObjectLiteralElement = getContainingObjectLiteralElement(location); - if (containingObjectLiteralElement && containingObjectLiteralElement.kind !== SyntaxKind.ShorthandPropertyAssignment) { - const propertySymbol = getPropertySymbolOfDestructuringAssignment(location, typeChecker); - if (propertySymbol) { - result.push(propertySymbol); - } - } - - // If the location is in a context sensitive location (i.e. in an object literal) try - // to get a contextual type for it, and add the property symbol from the contextual - // type to the search set if (containingObjectLiteralElement) { - forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, typeChecker), contextualSymbol => { - addRange(result, typeChecker.getRootSymbols(contextualSymbol)); + // If the location is name of property symbol from object literal destructuring pattern + // Search the property symbol + // for ( { property: p2 } of elems) { } + if (containingObjectLiteralElement.kind !== SyntaxKind.ShorthandPropertyAssignment) { + const propertySymbol = getPropertySymbolOfDestructuringAssignment(location, checker); + if (propertySymbol) { + result.push(propertySymbol); + } + } + + // If the location is in a context sensitive location (i.e. in an object literal) try + // to get a contextual type for it, and add the property symbol from the contextual + // type to the search set + forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, checker), contextualSymbol => { + addRange(result, checker.getRootSymbols(contextualSymbol)); }); /* Because in short-hand property assignment, location has two meaning : property name and as value of the property - * When we do findAllReference at the position of the short-hand property assignment, we would want to have references to position of - * property name and variable declaration of the identifier. - * Like in below example, when querying for all references for an identifier 'name', of the property assignment, the language service - * should show both 'name' in 'obj' and 'name' in variable declaration - * const name = "Foo"; - * const obj = { name }; - * In order to do that, we will populate the search set with the value symbol of the identifier as a value of the property assignment - * so that when matching with potential reference symbol, both symbols from property declaration and variable declaration - * will be included correctly. - */ - const shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(location.parent); + * When we do findAllReference at the position of the short-hand property assignment, we would want to have references to position of + * property name and variable declaration of the identifier. + * Like in below example, when querying for all references for an identifier 'name', of the property assignment, the language service + * should show both 'name' in 'obj' and 'name' in variable declaration + * const name = "Foo"; + * const obj = { name }; + * In order to do that, we will populate the search set with the value symbol of the identifier as a value of the property assignment + * so that when matching with potential reference symbol, both symbols from property declaration and variable declaration + * will be included correctly. + */ + const shorthandValueSymbol = checker.getShorthandAssignmentValueSymbol(location.parent); if (shorthandValueSymbol) { result.push(shorthandValueSymbol); } @@ -1096,26 +1274,26 @@ namespace ts.FindAllReferences { // Property Declaration symbol is a member of the class, so the symbol is stored in its class Declaration.symbol.members if (symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.Parameter && isParameterPropertyDeclaration(symbol.valueDeclaration)) { - addRange(result, typeChecker.getSymbolsOfParameterPropertyDeclaration(symbol.valueDeclaration, symbol.name)); + addRange(result, checker.getSymbolsOfParameterPropertyDeclaration(symbol.valueDeclaration, symbol.name)); } // If this is symbol of binding element without propertyName declaration in Object binding pattern // Include the property in the search - const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, typeChecker); + const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, checker); if (bindingElementPropertySymbol) { result.push(bindingElementPropertySymbol); } // If this is a union property, add all the symbols from all its source symbols in all unioned types. // If the symbol is an instantiation from a another symbol (e.g. widened symbol) , add the root the list - for (const rootSymbol of typeChecker.getRootSymbols(symbol)) { + for (const rootSymbol of checker.getRootSymbols(symbol)) { if (rootSymbol !== symbol) { result.push(rootSymbol); } // Add symbol of properties/methods of the same name in base classes and implemented interfaces definitions if (!implementations && rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) { - getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap(), typeChecker); + getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap(), checker); } } @@ -1130,8 +1308,7 @@ namespace ts.FindAllReferences { * @param previousIterationSymbolsCache a cache of symbol from previous iterations of calling this function to prevent infinite revisiting of the same symbol. * The value of previousIterationSymbol is undefined when the function is first called. */ - function getPropertySymbolsFromBaseTypes(symbol: Symbol, propertyName: string, result: Symbol[], - previousIterationSymbolsCache: SymbolTable, typeChecker: TypeChecker): void { + function getPropertySymbolsFromBaseTypes(symbol: Symbol, propertyName: string, result: Symbol[], previousIterationSymbolsCache: SymbolTable, checker: TypeChecker): void { if (!symbol) { return; } @@ -1164,34 +1341,26 @@ namespace ts.FindAllReferences { } return; - function getPropertySymbolFromTypeReference(typeReference: ExpressionWithTypeArguments) { + function getPropertySymbolFromTypeReference(typeReference: ExpressionWithTypeArguments): void { if (typeReference) { - const type = typeChecker.getTypeAtLocation(typeReference); + const type = checker.getTypeAtLocation(typeReference); if (type) { - const propertySymbol = typeChecker.getPropertyOfType(type, propertyName); + const propertySymbol = checker.getPropertyOfType(type, propertyName); if (propertySymbol) { - result.push(...typeChecker.getRootSymbols(propertySymbol)); + result.push(...checker.getRootSymbols(propertySymbol)); } // Visit the typeReference as well to see if it directly or indirectly use that property previousIterationSymbolsCache.set(symbol.name, symbol); - getPropertySymbolsFromBaseTypes(type.symbol, propertyName, result, previousIterationSymbolsCache, typeChecker); + getPropertySymbolsFromBaseTypes(type.symbol, propertyName, result, previousIterationSymbolsCache, checker); } } } } - function getRelatedSymbol(searchSymbols: Symbol[], referenceSymbol: Symbol, referenceLocation: Node, searchLocationIsConstructor: boolean, parents: Symbol[] | undefined, cache: Map, typeChecker: TypeChecker): Symbol | undefined { - if (contains(searchSymbols, referenceSymbol)) { - // If we are searching for constructor uses, they must be 'new' expressions. - return (!searchLocationIsConstructor || isNewExpressionTarget(referenceLocation)) ? referenceSymbol : undefined; - } - - // If the reference symbol is an alias, check if what it is aliasing is one of the search - // symbols but by looking up for related symbol of this alias so it can handle multiple level of indirectness. - const aliasSymbol = getAliasSymbolForPropertyNameSymbol(referenceSymbol, referenceLocation, typeChecker); - if (aliasSymbol) { - return getRelatedSymbol(searchSymbols, aliasSymbol, referenceLocation, searchLocationIsConstructor, parents, cache, typeChecker); + function getRelatedSymbol(search: Search, referenceSymbol: Symbol, referenceLocation: Node, state: State): Symbol | undefined { + if (search.includes(referenceSymbol)) { + return referenceSymbol; } // If the reference location is in an object literal, try to get the contextual type for the @@ -1199,8 +1368,8 @@ namespace ts.FindAllReferences { // compare to our searchSymbol const containingObjectLiteralElement = getContainingObjectLiteralElement(referenceLocation); if (containingObjectLiteralElement) { - const contextualSymbol = forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, typeChecker), contextualSymbol => - find(typeChecker.getRootSymbols(contextualSymbol), symbol => contains(searchSymbols, symbol))); + const contextualSymbol = forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, state.checker), contextualSymbol => + find(state.checker.getRootSymbols(contextualSymbol), search.includes)); if (contextualSymbol) { return contextualSymbol; @@ -1210,8 +1379,8 @@ namespace ts.FindAllReferences { // Get the property symbol from the object literal's type and look if thats the search symbol // In below eg. get 'property' from type of elems iterating type // for ( { property: p2 } of elems) { } - const propertySymbol = getPropertySymbolOfDestructuringAssignment(referenceLocation, typeChecker); - if (propertySymbol && contains(searchSymbols, propertySymbol)) { + const propertySymbol = getPropertySymbolOfDestructuringAssignment(referenceLocation, state.checker); + if (propertySymbol && search.includes(propertySymbol)) { return propertySymbol; } } @@ -1219,16 +1388,16 @@ namespace ts.FindAllReferences { // If the reference location is the binding element and doesn't have property name // then include the binding element in the related symbols // let { a } : { a }; - const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(referenceSymbol, typeChecker); - if (bindingElementPropertySymbol && contains(searchSymbols, bindingElementPropertySymbol)) { + const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(referenceSymbol, state.checker); + if (bindingElementPropertySymbol && search.includes(bindingElementPropertySymbol)) { return bindingElementPropertySymbol; } // Unwrap symbols to get to the root (e.g. transient symbols as a result of widening) // Or a union property, use its underlying unioned symbols - return forEach(typeChecker.getRootSymbols(referenceSymbol), rootSymbol => { + return forEach(state.checker.getRootSymbols(referenceSymbol), rootSymbol => { // if it is in the list, then we are done - if (contains(searchSymbols, rootSymbol)) { + if (search.includes(rootSymbol)) { return rootSymbol; } @@ -1237,22 +1406,20 @@ namespace ts.FindAllReferences { // parent symbol if (rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) { // Parents will only be defined if implementations is true - if (parents) { - if (!forEach(parents, parent => explicitlyInheritsFrom(rootSymbol.parent, parent, cache, typeChecker))) { - return undefined; - } + if (search.parents && !some(search.parents, parent => explicitlyInheritsFrom(rootSymbol.parent, parent, state.inheritsFromCache, state.checker))) { + return undefined; } const result: Symbol[] = []; - getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap(), typeChecker); - return find(result, symbol => contains(searchSymbols, symbol)); + getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap(), state.checker); + return find(result, search.includes); } return undefined; }); } - function getNameFromObjectLiteralElement(node: ObjectLiteralElement) { + function getNameFromObjectLiteralElement(node: ObjectLiteralElement): string { if (node.name.kind === SyntaxKind.ComputedPropertyName) { const nameExpression = (node.name).expression; // treat computed property names where expression is string/numeric literal as just string/numeric literal @@ -1265,9 +1432,9 @@ namespace ts.FindAllReferences { } /** Gets all symbols for one property. Does not get symbols for every property. */ - function getPropertySymbolsFromContextualType(node: ObjectLiteralElement, typeChecker: TypeChecker): Symbol[] | undefined { + function getPropertySymbolsFromContextualType(node: ObjectLiteralElement, checker: TypeChecker): Symbol[] | undefined { const objectLiteral = node.parent; - const contextualType = typeChecker.getContextualType(objectLiteral); + const contextualType = checker.getContextualType(objectLiteral); const name = getNameFromObjectLiteralElement(node); if (name && contextualType) { const result: Symbol[] = []; @@ -1357,34 +1524,36 @@ namespace ts.FindAllReferences { } } - export function getReferenceEntriesForShorthandPropertyAssignment(node: Node, typeChecker: TypeChecker, result: ReferenceEntry[]): void { - const refSymbol = typeChecker.getSymbolAtLocation(node); - const shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(refSymbol.valueDeclaration); + function getReferenceEntriesForShorthandPropertyAssignment(node: Node, checker: TypeChecker, addReference: (node: Node) => void): void { + const refSymbol = checker.getSymbolAtLocation(node); + const shorthandSymbol = checker.getShorthandAssignmentValueSymbol(refSymbol.valueDeclaration); if (shorthandSymbol) { for (const declaration of shorthandSymbol.getDeclarations()) { if (getMeaningFromDeclaration(declaration) & SemanticMeaning.Value) { - result.push(getReferenceEntryFromNode(declaration)); + addReference(declaration); } } } } - export function getReferenceEntryFromNode(node: Node): ReferenceEntry { + function getReferenceEntryFromNode(node: Node): ReferenceEntry { + return { + fileName: node.getSourceFile().fileName, + textSpan: getTextSpan(node), + isWriteAccess: isWriteAccess(node), + isDefinition: isDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node) + }; + } + + function getTextSpan(node: Node): TextSpan { let start = node.getStart(); let end = node.getEnd(); - if (node.kind === SyntaxKind.StringLiteral) { start += 1; end -= 1; } - - return { - fileName: node.getSourceFile().fileName, - textSpan: createTextSpanFromBounds(start, end), - isWriteAccess: isWriteAccess(node), - isDefinition: isDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node) - }; + return createTextSpanFromBounds(start, end); } /** A node is considered a writeAccess iff it is a name of a declaration or a target of an assignment */ @@ -1407,7 +1576,7 @@ namespace ts.FindAllReferences { return false; } - function forEachDescendantOfKind(node: Node, kind: SyntaxKind, action: (node: Node) => void) { + function forEachDescendantOfKind(node: Node, kind: SyntaxKind, action: (node: Node) => void): void { forEachChild(node, child => { if (child.kind === kind) { action(child); @@ -1429,7 +1598,47 @@ namespace ts.FindAllReferences { return false; } - function isImportDefaultSymbol(symbol: Symbol): boolean { - return symbol.declarations[0].kind === SyntaxKind.ImportClause; + function skipAliases(symbol: Symbol, checker: TypeChecker): Symbol { + return symbol.flags & SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol; + } + + /** + * If we are just looking for implementations and this is a property access expression, we need to get the + * symbol of the local type of the symbol the property is being accessed on. This is because our search + * symbol may have a different parent symbol if the local type's symbol does not declare the property + * being accessed (i.e. it is declared in some parent class or interface) + */ + function getParentSymbolsOfPropertyAccess(location: Node, symbol: Symbol, checker: TypeChecker): Symbol[] | undefined { + const propertyAccessExpression = getPropertyAccessExpressionFromRightHandSide(location); + if (!propertyAccessExpression) { + return undefined; + } + + const localParentType = checker.getTypeAtLocation(propertyAccessExpression.expression); + if (!localParentType) { + return undefined; + } + + if (localParentType.symbol && localParentType.symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) && localParentType.symbol !== symbol.parent) { + return [localParentType.symbol]; + } + else if (localParentType.flags & TypeFlags.UnionOrIntersection) { + return getSymbolsForClassAndInterfaceComponents(localParentType); + } + } + + /** True if the symbol is for an external module, as opposed to a namespace. */ + export function isExternalModuleSymbol(moduleSymbol: Symbol): boolean { + Debug.assert(!!(moduleSymbol.flags & SymbolFlags.Module)); + return moduleSymbol.name.charCodeAt(0) === CharacterCodes.doubleQuote; + } + + /** Returns `true` the first time it encounters a node and `false` afterwards. */ + export function nodeSeenTracker(): (node: T) => boolean { + const seen: Array = []; + return node => { + const id = getNodeId(node); + return !seen[id] && (seen[id] = true); + }; } } diff --git a/src/services/goToImplementation.ts b/src/services/goToImplementation.ts deleted file mode 100644 index 9135e1fe0f0..00000000000 --- a/src/services/goToImplementation.ts +++ /dev/null @@ -1,27 +0,0 @@ -/* @internal */ -namespace ts.GoToImplementation { - export function getImplementationAtPosition(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], node: Node): ImplementationLocation[] { - // If invoked directly on a shorthand property assignment, then return - // the declaration of the symbol being assigned (not the symbol being assigned to). - if (node.parent.kind === SyntaxKind.ShorthandPropertyAssignment) { - const result: ReferenceEntry[] = []; - FindAllReferences.getReferenceEntriesForShorthandPropertyAssignment(node, typeChecker, result); - return result.length > 0 ? result : undefined; - } - else if (node.kind === SyntaxKind.SuperKeyword || isSuperProperty(node.parent)) { - // References to and accesses on the super keyword only have one possible implementation, so no - // need to "Find all References" - const symbol = typeChecker.getSymbolAtLocation(node); - return symbol.valueDeclaration && [FindAllReferences.getReferenceEntryFromNode(symbol.valueDeclaration)]; - } - else { - // Perform "Find all References" and retrieve only those that are implementations - const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken, - node, sourceFiles, /*findInStrings*/false, /*findInComments*/false, /*isForRename*/false, /*implementations*/true); - const result = flatMap(referencedSymbols, symbol => - map(symbol.references, ({ textSpan, fileName }) => ({ textSpan, fileName }))); - - return result && result.length > 0 ? result : undefined; - } - } -} diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts new file mode 100644 index 00000000000..3f4e896faf2 --- /dev/null +++ b/src/services/importTracker.ts @@ -0,0 +1,527 @@ +/* Code for finding imports of an exported symbol. Used only by FindAllReferences. */ +/* @internal */ +namespace ts.FindAllReferences { + export interface ImportsResult { + /** For every import of the symbol, the location and local symbol for the import. */ + importSearches: Array<[Identifier, Symbol]>; + /** For rename imports/exports `{ foo as bar }`, `foo` is not a local, so it may be added as a reference immediately without further searching. */ + singleReferences: Identifier[]; + /** List of source files that may (or may not) use the symbol via a namespace. (For UMD modules this is every file.) */ + indirectUsers: SourceFile[]; + } + export type ImportTracker = (exportSymbol: Symbol, exportInfo: ExportInfo, isForRename: boolean) => ImportsResult; + + /** Creates the imports map and returns an ImportTracker that uses it. Call this lazily to avoid calling `getDirectImportsMap` unnecessarily. */ + export function createImportTracker(sourceFiles: SourceFile[], checker: TypeChecker): ImportTracker { + const allDirectImports = getDirectImportsMap(sourceFiles, checker); + return (exportSymbol, exportInfo, isForRename) => { + const { directImports, indirectUsers } = getImportersForExport(sourceFiles, allDirectImports, exportInfo, checker); + return { indirectUsers, ...getSearchesFromDirectImports(directImports, exportSymbol, exportInfo.exportKind, checker, isForRename) }; + } + } + + /** Info about an exported symbol to perform recursive search on. */ + export interface ExportInfo { + exportingModuleSymbol: Symbol; + exportKind: ExportKind; + } + + export const enum ExportKind { Named, Default, ExportEquals } + + export const enum ImportExport { Import, Export } + + interface AmbientModuleDeclaration extends ModuleDeclaration { body?: ModuleBlock; } + type SourceFileLike = SourceFile | AmbientModuleDeclaration; + type Importer = AnyImportSyntax | ExportDeclaration; + type ImporterOrCallExpression = Importer | CallExpression; + + /** Returns import statements that directly reference the exporting module, and a list of files that may access the module through a namespace. */ + function getImportersForExport(sourceFiles: SourceFile[], allDirectImports: ImporterOrCallExpression[][], { exportingModuleSymbol, exportKind }: ExportInfo, checker: TypeChecker): { directImports: Importer[], indirectUsers: SourceFile[] } { + const markSeenDirectImport = nodeSeenTracker(); + const markSeenIndirectUser = nodeSeenTracker(); + const directImports: Importer[] = []; + const isAvailableThroughGlobal = !!exportingModuleSymbol.globalExports; + const indirectUserDeclarations: SourceFileLike[] = isAvailableThroughGlobal ? undefined : []; + + handleDirectImports(exportingModuleSymbol); + + return { directImports, indirectUsers: getIndirectUsers() }; + + function getIndirectUsers(): SourceFile[] { + if (isAvailableThroughGlobal) { + // It has `export as namespace`, so anything could potentially use it. + return sourceFiles; + } + + // Module augmentations may use this module's exports without importing it. + for (const decl of exportingModuleSymbol.declarations) { + if (ts.isExternalModuleAugmentation(decl)) { + addIndirectUser(decl as SourceFileLike); + } + } + + // This may return duplicates (if there are multiple module declarations in a single source file, all importing the same thing as a namespace), but `State.markSearchedSymbol` will handle that. + return indirectUserDeclarations.map(getSourceFileOfNode); + } + + function handleDirectImports(exportingModuleSymbol: Symbol): void { + const theseDirectImports = getDirectImports(exportingModuleSymbol); + if (theseDirectImports) for (const direct of theseDirectImports) { + if (!markSeenDirectImport(direct)) { + continue; + } + + switch (direct.kind) { + case SyntaxKind.CallExpression: + if (!isAvailableThroughGlobal) { + // Don't support re-exporting 'require()' calls, so just add a single indirect user. + addIndirectUser(direct.getSourceFile()); + } + break; + + case SyntaxKind.ImportEqualsDeclaration: + handleNamespaceImport(direct, direct.name, hasModifier(direct, ModifierFlags.Export)); + break; + + case SyntaxKind.ImportDeclaration: + const namedBindings = direct.importClause && direct.importClause.namedBindings; + if (namedBindings && namedBindings.kind === SyntaxKind.NamespaceImport) { + handleNamespaceImport(direct, namedBindings.name) + } + else { + directImports.push(direct); + } + break; + + case SyntaxKind.ExportDeclaration: + if (!direct.exportClause) { + // This is `export * from "foo"`, so imports of this module may import the export too. + handleDirectImports(getContainingModuleSymbol(direct, checker)); + } + else { + // This is `export { foo } from "foo"` and creates an alias symbol, so recursive search will get handle re-exports. + directImports.push(direct); + } + break; + } + } + } + + function handleNamespaceImport(importDeclaration: ImportEqualsDeclaration | ImportDeclaration, name: Identifier, isReExport?: boolean): void { + if (exportKind === ExportKind.ExportEquals) { + // This is a direct import, not import-as-namespace. + directImports.push(importDeclaration); + } + else if (!isAvailableThroughGlobal) { + const sourceFileLike = getSourceFileLikeForImportDeclaration(importDeclaration); + Debug.assert(sourceFileLike.kind === SyntaxKind.SourceFile || sourceFileLike.kind === SyntaxKind.ModuleDeclaration); + if (isReExport || findNamespaceReExports(sourceFileLike, name, checker)) { + addIndirectUsers(sourceFileLike); + } + else { + addIndirectUser(sourceFileLike); + } + } + } + + function addIndirectUser(sourceFileLike: SourceFileLike): boolean { + Debug.assert(!isAvailableThroughGlobal); + const isNew = markSeenIndirectUser(sourceFileLike); + if (isNew) { + indirectUserDeclarations.push(sourceFileLike); + } + return isNew; + } + + /** Adds a module and all of its transitive dependencies as possible indirect users. */ + function addIndirectUsers(sourceFileLike: SourceFileLike): void { + if (!addIndirectUser(sourceFileLike)) { + return; + } + + const moduleSymbol = checker.getMergedSymbol(sourceFileLike.symbol); + Debug.assert(!!(moduleSymbol.flags & SymbolFlags.Module)); + const directImports = getDirectImports(moduleSymbol); + if (directImports) for (const directImport of directImports) { + addIndirectUsers(getSourceFileLikeForImportDeclaration(directImport)); + } + } + + function getDirectImports(moduleSymbol: Symbol): ImporterOrCallExpression[] | undefined { + return allDirectImports[getSymbolId(moduleSymbol)]; + } + } + + /** + * Given the set of direct imports of a module, we need to find which ones import the particular exported symbol. + * The returned `importSearches` will result in the entire source file being searched. + * But re-exports will be placed in 'singleReferences' since they cannot be locally referenced. + */ + function getSearchesFromDirectImports(directImports: Importer[], exportSymbol: Symbol, exportKind: ExportKind, checker: TypeChecker, isForRename: boolean): Pick { + const exportName = exportSymbol.name; + const importSearches: Array<[Identifier, Symbol]> = []; + const singleReferences: Identifier[] = []; + function addSearch(location: Identifier, symbol: Symbol): void { + importSearches.push([location, symbol]); + } + + if (directImports) for (const decl of directImports) { + handleImport(decl); + } + + return { importSearches, singleReferences }; + + function handleImport(decl: Importer): void { + if (decl.kind === SyntaxKind.ImportEqualsDeclaration) { + if (isProperImportEquals(decl)) { + handleNamespaceImportLike(decl.name); + } + return; + } + + // Ignore if there's a grammar error + if (decl.moduleSpecifier.kind !== SyntaxKind.StringLiteral) { + return; + } + + if (decl.kind === SyntaxKind.ExportDeclaration) { + searchForNamedImport(decl.exportClause); + return; + } + + const { importClause } = decl; + + const { namedBindings } = importClause; + if (namedBindings && namedBindings.kind === ts.SyntaxKind.NamespaceImport) { + handleNamespaceImportLike(namedBindings.name); + return; + } + + if (exportKind === ExportKind.Named) { + searchForNamedImport(namedBindings as NamedImports | undefined); + } + else { + // `export =` might be imported by a default import if `--allowSyntheticDefaultImports` is on, so this handles both ExportKind.Default and ExportKind.ExportEquals + const { name } = importClause; + // If a default import has the same name as the default export, allow to rename it. + // Given `import f` and `export default function f`, we will rename both, but for `import g` we will rename just that. + if (name && (!isForRename || name.text === symbolName(exportSymbol))) { + const defaultImportAlias = checker.getSymbolAtLocation(name); + addSearch(name, defaultImportAlias); + } + + // 'default' might be accessed as a named import `{ default as foo }`. + if (!isForRename && exportKind === ExportKind.Default) { + Debug.assert(exportName === "default"); + searchForNamedImport(namedBindings as NamedImports | undefined); + } + } + } + + /** + * `import x = require("./x") or `import * as x from "./x"`. + * An `export =` may be imported by this syntax, so it may be a direct import. + * If it's not a direct import, it will be in `indirectUsers`, so we don't have to do anything here. + */ + function handleNamespaceImportLike(importName: Identifier): void { + // Don't rename an import that already has a different name than the export. + if (exportKind === ExportKind.ExportEquals && (!isForRename || importName.text === exportName)) { + addSearch(importName, checker.getSymbolAtLocation(importName)); + } + } + + function searchForNamedImport(namedBindings: NamedImportsOrExports | undefined): void { + if (namedBindings) for (const element of namedBindings.elements) { + const { name, propertyName } = element; + if ((propertyName || name).text !== exportName) { + continue; + } + + if (propertyName) { + // This is `import { foo as bar } from "./a"` or `export { foo as bar } from "./a"`. `foo` isn't a local in the file, so just add it as a single reference. + singleReferences.push(propertyName); + if (!isForRename) { // If renaming `foo`, don't touch `bar`, just `foo`. + // Search locally for `bar`. + addSearch(name, checker.getSymbolAtLocation(name)); + } + } + else { + const localSymbol = element.kind === SyntaxKind.ExportSpecifier && element.propertyName + ? checker.getExportSpecifierLocalTargetSymbol(element) // For re-exporting under a different name, we want to get the re-exported symbol. + : checker.getSymbolAtLocation(name); + addSearch(name, localSymbol); + } + } + } + } + + /** Returns 'true' is the namespace 'name' is re-exported from this module, and 'false' if it is only used locally. */ + function findNamespaceReExports(sourceFileLike: SourceFileLike, name: Identifier, checker: TypeChecker): boolean { + const namespaceImportSymbol = checker.getSymbolAtLocation(name); + + return forEachPossibleImportOrExportStatement(sourceFileLike, statement => { + if (statement.kind !== SyntaxKind.ExportDeclaration) return; + + const { exportClause, moduleSpecifier } = statement as ExportDeclaration; + if (moduleSpecifier || !exportClause) return; + + for (const element of exportClause.elements) { + if (checker.getExportSpecifierLocalTargetSymbol(element) === namespaceImportSymbol) { + return true; + } + } + }); + } + + /** Returns a map from a module symbol Id to all import statements that directly reference the module. */ + function getDirectImportsMap(sourceFiles: SourceFile[], checker: TypeChecker): ImporterOrCallExpression[][] { + const map: ImporterOrCallExpression[][] = []; + + for (const sourceFile of sourceFiles) { + forEachImport(sourceFile, (importDecl, moduleSpecifier) => { + const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier); + if (moduleSymbol) { + const id = getSymbolId(moduleSymbol); + let imports = map[id]; + if (!imports) { + imports = map[id] = []; + } + imports.push(importDecl); + } + }); + } + + return map; + } + + /** Iterates over all statements at the top level or in module declarations. Returns the first truthy result. */ + function forEachPossibleImportOrExportStatement(sourceFileLike: SourceFileLike, action: (statement: Statement) => T): T { + return forEach(sourceFileLike.kind === SyntaxKind.SourceFile ? sourceFileLike.statements : sourceFileLike.body.statements, statement => + action(statement) || (isAmbientModuleDeclaration(statement) && forEach(statement.body && statement.body.statements, action))); + } + + /** Calls `action` for each import, re-export, or require() in a file. */ + function forEachImport(sourceFile: SourceFile, action: (importStatement: ImporterOrCallExpression, imported: StringLiteral) => void): void { + if (sourceFile.externalModuleIndicator) { + for (const moduleSpecifier of sourceFile.imports) { + action(importerFromModuleSpecifier(moduleSpecifier), moduleSpecifier); + } + } + else { + forEachPossibleImportOrExportStatement(sourceFile, statement => { + switch (statement.kind) { + case SyntaxKind.ExportDeclaration: + case SyntaxKind.ImportDeclaration: { + const decl = statement as ImportDeclaration | ExportDeclaration; + if (decl.moduleSpecifier && decl.moduleSpecifier.kind === SyntaxKind.StringLiteral) { + action(decl, decl.moduleSpecifier as StringLiteral); + } + break; + } + + case SyntaxKind.ImportEqualsDeclaration: { + const decl = statement as ImportEqualsDeclaration; + const { moduleReference } = decl; + if (moduleReference.kind === SyntaxKind.ExternalModuleReference && + moduleReference.expression.kind === SyntaxKind.StringLiteral) { + action(decl, moduleReference.expression as StringLiteral); + } + break; + } + } + }); + + if (sourceFile.flags & NodeFlags.JavaScriptFile) { + // Find all 'require()' calls. + recur(sourceFile); + function recur(node: Node): void { + if (isRequireCall(node, /*checkArgumentIsStringLiteral*/true)) { + action(node, node.arguments[0] as StringLiteral); + } + forEachChild(node, recur); + } + } + } + } + + function importerFromModuleSpecifier(moduleSpecifier: StringLiteral): Importer { + const decl = moduleSpecifier.parent; + if (decl.kind === SyntaxKind.ImportDeclaration || decl.kind === SyntaxKind.ExportDeclaration) { + return decl as ImportDeclaration | ExportDeclaration; + } + Debug.assert(decl.kind === SyntaxKind.ExternalModuleReference); + return (decl as ExternalModuleReference).parent; + } + + export interface ImportedSymbol { + kind: ImportExport.Import; + symbol: Symbol; + isNamedImport: boolean; + } + export interface ExportedSymbol { + kind: ImportExport.Export; + symbol: Symbol; + exportInfo: ExportInfo; + } + /** + * Given a local reference, we might notice that it's an import/export and recursively search for references of that. + * If at an import, look locally for the symbol it imports. + * If an an export, look for all imports of it. + * @param comingFromExport If we are doing a search for all exports, don't bother looking backwards for the imported symbol, since that's the reason we're here. + */ + export function getImportOrExportSymbol(node: Node, symbol: Symbol, checker: TypeChecker, comingFromExport: boolean): ImportedSymbol | ExportedSymbol | undefined { + const ex = getExport(); + return ex || comingFromExport ? ex : getImport(); + + function getExport(): ExportedSymbol | ImportedSymbol | undefined { + const { parent } = node; + if (symbol.flags & SymbolFlags.Export) { + if (parent.kind === SyntaxKind.PropertyAccessExpression) { + // When accessing an export of a JS module, there's no alias. The symbol will still be flagged as an export even though we're at the use. + // So check that we are at the declaration. + if (!symbol.declarations.some(d => d === parent)) { + return undefined; + } + + switch (getSpecialPropertyAssignmentKind(parent.parent)) { + case SpecialPropertyAssignmentKind.ExportsProperty: + return exportInfo(symbol, ExportKind.Named); + case SpecialPropertyAssignmentKind.ModuleExports: + return exportInfo(symbol, ExportKind.ExportEquals); + default: + return undefined; + } + } + else { + const { exportSymbol } = symbol; + Debug.assert(!!exportSymbol); + return exportInfo(exportSymbol, getExportKindForDeclaration(parent)); + } + } + else { + const exportNode = parent.kind === SyntaxKind.VariableDeclaration ? getAncestor(parent, SyntaxKind.VariableStatement) : parent; + if (hasModifier(exportNode, ModifierFlags.Export)) { + if (exportNode.kind === SyntaxKind.ImportEqualsDeclaration && (exportNode as ImportEqualsDeclaration).moduleReference === node) { + // We're at `Y` in `export import X = Y`. This is not the exported symbol, the left-hand-side is. So treat this as an import statement. + if (comingFromExport) { + return undefined; + } + + const lhsSymbol = checker.getSymbolAtLocation((exportNode as ImportEqualsDeclaration).name); + return { kind: ImportExport.Import, symbol: lhsSymbol, isNamedImport: false }; + } + else { + return exportInfo(symbol, getExportKindForDeclaration(exportNode)); + } + } + else if (parent.kind === SyntaxKind.ExportAssignment) { + // Get the symbol for the `export =` node; its parent is the module it's the export of. + const exportingModuleSymbol = parent.symbol.parent; + Debug.assert(!!exportingModuleSymbol); + return { kind: ImportExport.Export, symbol, exportInfo: { exportingModuleSymbol, exportKind: ExportKind.ExportEquals } } + } + } + } + + function getImport(): ImportedSymbol | undefined { + const isImport = isNodeImport(node); + if (!isImport) return; + + // A symbol being imported is always an alias. So get what that aliases to find the local symbol. + let importedSymbol = checker.getImmediateAliasedSymbol(symbol); + if (importedSymbol) { + // Search on the local symbol in the exporting module, not the exported symbol. + importedSymbol = skipExportSpecifierSymbol(importedSymbol, checker); + // Similarly, skip past the symbol for 'export =' + if (importedSymbol.name === "export=") { + importedSymbol = checker.getImmediateAliasedSymbol(importedSymbol); + } + + if (symbolName(importedSymbol) === symbol.name) { // If this is a rename import, do not continue searching. + return { kind: ImportExport.Import, symbol: importedSymbol, ...isImport }; + } + } + } + + function exportInfo(symbol: Symbol, kind: ExportKind): ExportedSymbol { + const exportInfo = getExportInfo(symbol, kind, checker); + return exportInfo && { kind: ImportExport.Export, symbol, exportInfo } + } + + // Not meant for use with export specifiers or export assignment. + function getExportKindForDeclaration(node: Node): ExportKind | undefined { + return hasModifier(node, ModifierFlags.Default) ? ExportKind.Default : ExportKind.Named; + } + } + + function isNodeImport(node: Node): { isNamedImport: boolean } | undefined { + const { parent } = node; + switch (parent.kind) { + case SyntaxKind.ImportEqualsDeclaration: + return (parent as ImportEqualsDeclaration).name === node ? { isNamedImport: false } : undefined; + case SyntaxKind.ImportSpecifier: + // For a rename import `{ foo as bar }`, don't search for the imported symbol. Just find local uses of `bar`. + return (parent as ImportSpecifier).propertyName ? undefined : { isNamedImport: true }; + case SyntaxKind.ImportClause: + case SyntaxKind.NamespaceImport: + Debug.assert((parent as ImportClause | NamespaceImport).name === node); + return { isNamedImport: false }; + default: + return undefined; + } + } + + export function getExportInfo(exportSymbol: Symbol, exportKind: ExportKind, checker: TypeChecker): ExportInfo | undefined { + const exportingModuleSymbol = checker.getMergedSymbol(exportSymbol.parent); // Need to get merged symbol in case there's an augmentation. + // `export` may appear in a namespace. In that case, just rely on global search. + return isExternalModuleSymbol(exportingModuleSymbol) ? { exportingModuleSymbol, exportKind } : undefined; + } + + function symbolName(symbol: Symbol): string { + if (symbol.name !== "default") { + return symbol.name; + } + + const name = forEach(symbol.declarations, ({ name }) => name && name.kind === SyntaxKind.Identifier && name.text); + Debug.assert(!!name); + return name; + } + + /** If at an export specifier, go to the symbol it refers to. */ + function skipExportSpecifierSymbol(symbol: Symbol, checker: TypeChecker): Symbol { + // For `export { foo } from './bar", there's nothing to skip, because it does not create a new alias. But `export { foo } does. + for (const declaration of symbol.declarations) { + if (isExportSpecifier(declaration) && !(declaration as ExportSpecifier).propertyName && !(declaration as ExportSpecifier).parent.parent.moduleSpecifier) { + return checker.getExportSpecifierLocalTargetSymbol(declaration); + } + } + + return symbol; + } + + function getContainingModuleSymbol(importer: Importer, checker: TypeChecker): Symbol { + return checker.getMergedSymbol(getSourceFileLikeForImportDeclaration(importer).symbol); + } + + function getSourceFileLikeForImportDeclaration(node: ImporterOrCallExpression): SourceFileLike { + if (node.kind === SyntaxKind.CallExpression) { + return node.getSourceFile(); + } + + const { parent } = node; + + if (parent.kind === SyntaxKind.SourceFile) { + return parent as SourceFile; + } + Debug.assert(parent.kind === SyntaxKind.ModuleBlock && isAmbientModuleDeclaration(parent.parent)); + return parent.parent as AmbientModuleDeclaration; + } + + function isAmbientModuleDeclaration(node: Node): node is AmbientModuleDeclaration { + return node.kind === SyntaxKind.ModuleDeclaration && (node as ModuleDeclaration).name.kind === SyntaxKind.StringLiteral; + } + + function isProperImportEquals({ moduleReference }: ImportEqualsDeclaration): boolean { + return moduleReference.kind === SyntaxKind.ExternalModuleReference && moduleReference.expression.kind === SyntaxKind.StringLiteral + } +} diff --git a/src/services/rename.ts b/src/services/rename.ts index 2e9396888ef..556283a44f4 100644 --- a/src/services/rename.ts +++ b/src/services/rename.ts @@ -84,8 +84,12 @@ namespace ts.Rename { return createTextSpan(start, width); } - function nodeIsEligibleForRename(node: Node) { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral || + function nodeIsEligibleForRename(node: Node): boolean { + if (node.kind === SyntaxKind.Identifier) { + // Cannot rename `default` as in `import { default as foo } from "./someModule"; + return (node as Identifier).originalKeywordKind !== SyntaxKind.DefaultKeyword; + } + return node.kind === SyntaxKind.StringLiteral || isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || isThis(node); } diff --git a/src/services/services.ts b/src/services/services.ts index c1b719d3477..3df457fe729 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -10,7 +10,6 @@ /// /// /// -/// /// /// /// @@ -469,8 +468,8 @@ namespace ts { public nameTable: Map; public resolvedModules: Map; public resolvedTypeReferenceDirectiveNames: Map; - public imports: LiteralExpression[]; - public moduleAugmentations: LiteralExpression[]; + public imports: StringLiteral[]; + public moduleAugmentations: StringLiteral[]; private namedDeclarations: Map; public ambientModuleNames: string[]; @@ -1344,18 +1343,18 @@ namespace ts { return GoToDefinition.getDefinitionAtPosition(program, getValidSourceFile(fileName), position); } - /// Goto implementation - function getImplementationAtPosition(fileName: string, position: number): ImplementationLocation[] { - synchronizeHostData(); - return GoToImplementation.getImplementationAtPosition(program.getTypeChecker(), cancellationToken, - program.getSourceFiles(), getTouchingPropertyName(getValidSourceFile(fileName), position)); - } - function getTypeDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[] { synchronizeHostData(); return GoToDefinition.getTypeDefinitionAtPosition(program.getTypeChecker(), getValidSourceFile(fileName), position); } + /// Goto implementation + function getImplementationAtPosition(fileName: string, position: number): ImplementationLocation[] { + synchronizeHostData(); + return FindAllReferences.getImplementationsAtPosition(program.getTypeChecker(), cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position); + } + + /// References and Occurrences function getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[] { let results = getOccurrencesAtPositionCore(fileName, position); @@ -1377,10 +1376,7 @@ namespace ts { return DocumentHighlights.getDocumentHighlights(program.getTypeChecker(), cancellationToken, sourceFile, position, sourceFilesToSearch); } - /// References and Occurrences function getOccurrencesAtPositionCore(fileName: string, position: number): ReferenceEntry[] { - synchronizeHostData(); - return convertDocumentHighlights(getDocumentHighlights(fileName, position, [fileName])); function convertDocumentHighlights(documentHighlights: DocumentHighlights[]): ReferenceEntry[] { @@ -1405,24 +1401,21 @@ namespace ts { } function findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[] { - const referencedSymbols = findReferencedSymbols(fileName, position, findInStrings, findInComments, /*isForRename*/true); - return FindAllReferences.convertReferences(referencedSymbols); + return getReferences(fileName, position, { findInStrings, findInComments, isForRename: true }); } function getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[] { - const referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings*/ false, /*findInComments*/ false, /*isForRename*/false); - return FindAllReferences.convertReferences(referencedSymbols); + return getReferences(fileName, position); + } + + function getReferences(fileName: string, position: number, options?: FindAllReferences.Options) { + synchronizeHostData(); + return FindAllReferences.findReferencedEntries(program.getTypeChecker(), cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position, options); } function findReferences(fileName: string, position: number): ReferencedSymbol[] { - const referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings*/ false, /*findInComments*/ false, /*isForRename*/false); - // Only include referenced symbols that have a valid definition. - return filter(referencedSymbols, rs => !!rs.definition); - } - - function findReferencedSymbols(fileName: string, position: number, findInStrings: boolean, findInComments: boolean, isForRename: boolean): ReferencedSymbol[] { synchronizeHostData(); - return FindAllReferences.findReferencedSymbols(program.getTypeChecker(), cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position, findInStrings, findInComments, isForRename); + return FindAllReferences.findReferencedSymbols(program.getTypeChecker(), cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position); } /// NavigateTo @@ -1944,6 +1937,7 @@ namespace ts { } /* @internal */ + /** Names in the name table are escaped, so an identifier `__foo` will have a name table entry `___foo`. */ export function getNameTable(sourceFile: SourceFile): Map { if (!sourceFile.nameTable) { initializeNameTable(sourceFile); diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json index b4e8289f367..9ebd3102efe 100644 --- a/src/services/tsconfig.json +++ b/src/services/tsconfig.json @@ -46,8 +46,8 @@ "documentHighlights.ts", "documentRegistry.ts", "findAllReferences.ts", + "importTracker.ts", "goToDefinition.ts", - "goToImplementation.ts", "jsDoc.ts", "jsTyping.ts", "navigateTo.ts", diff --git a/src/services/utilities.ts b/src/services/utilities.ts index a4f574b9c28..e5efbf9fe24 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -1304,21 +1304,14 @@ namespace ts { export function getDeclaredName(typeChecker: TypeChecker, symbol: Symbol, location: Node): string { // If this is an export or import specifier it could have been renamed using the 'as' syntax. // If so we want to search for whatever is under the cursor. - if (isImportOrExportSpecifierName(location)) { - return location.getText(); - } - else if (isStringOrNumericLiteral(location) && - location.parent.kind === SyntaxKind.ComputedPropertyName) { - return (location).text; + if (isImportOrExportSpecifierName(location) || isStringOrNumericLiteral(location) && location.parent.kind === SyntaxKind.ComputedPropertyName) { + return location.text; } // Try to get the local symbol if we're dealing with an 'export default' // since that symbol has the "true" name. const localExportDefaultSymbol = getLocalSymbolForExportDefault(symbol); - - const name = typeChecker.symbolToString(localExportDefaultSymbol || symbol); - - return name; + return typeChecker.symbolToString(localExportDefaultSymbol || symbol); } export function isImportOrExportSpecifierName(location: Node): location is Identifier { diff --git a/tests/cases/fourslash/ambientShorthandFindAllRefs.ts b/tests/cases/fourslash/ambientShorthandFindAllRefs.ts index 06bc6e94782..3f325a546c2 100644 --- a/tests/cases/fourslash/ambientShorthandFindAllRefs.ts +++ b/tests/cases/fourslash/ambientShorthandFindAllRefs.ts @@ -11,11 +11,6 @@ const ranges = test.ranges(); const [r0, r1] = ranges; -verify.referenceGroups(r0, [ - { definition: "import x", ranges: [r0] }, - { definition: 'module "jquery"', ranges: [r1] } -]); -verify.referenceGroups(r1, [ - { definition: 'module "jquery"', ranges: [r0] }, - { definition: "import x", ranges: [r1] } -]); +// TODO: Want these to be in the same group, but that would require creating a symbol for `x`. +verify.singleReferenceGroup("import x", [r0]); +verify.singleReferenceGroup("import x", [r1]); \ No newline at end of file diff --git a/tests/cases/fourslash/ambientVariablesWithSameName.ts b/tests/cases/fourslash/ambientVariablesWithSameName.ts index 45020cc2c32..30e8889875d 100644 --- a/tests/cases/fourslash/ambientVariablesWithSameName.ts +++ b/tests/cases/fourslash/ambientVariablesWithSameName.ts @@ -7,4 +7,4 @@ goTo.eof(); edit.insertLine(''); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); diff --git a/tests/cases/fourslash/cloduleAsBaseClass.ts b/tests/cases/fourslash/cloduleAsBaseClass.ts index 89f7b8ce8a7..96b258aed44 100644 --- a/tests/cases/fourslash/cloduleAsBaseClass.ts +++ b/tests/cases/fourslash/cloduleAsBaseClass.ts @@ -42,4 +42,4 @@ verify.completionListContains('baz'); verify.completionListContains('x'); edit.insert('bar()'); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/cloduleAsBaseClass2.ts b/tests/cases/fourslash/cloduleAsBaseClass2.ts index 995348fc7d1..d81c4a8c11b 100644 --- a/tests/cases/fourslash/cloduleAsBaseClass2.ts +++ b/tests/cases/fourslash/cloduleAsBaseClass2.ts @@ -46,4 +46,4 @@ verify.completionListContains('baz'); verify.completionListContains('x'); edit.insert('bar()'); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); diff --git a/tests/cases/fourslash/cloduleTypeOf1.ts b/tests/cases/fourslash/cloduleTypeOf1.ts index 31394342110..189a0664ef3 100644 --- a/tests/cases/fourslash/cloduleTypeOf1.ts +++ b/tests/cases/fourslash/cloduleTypeOf1.ts @@ -30,4 +30,4 @@ edit.insert('x;'); verify.quickInfoAt("5", "(local var) r2: number"); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/cloduleWithRecursiveReference.ts b/tests/cases/fourslash/cloduleWithRecursiveReference.ts index 41b12581ecc..a0fb69040ff 100644 --- a/tests/cases/fourslash/cloduleWithRecursiveReference.ts +++ b/tests/cases/fourslash/cloduleWithRecursiveReference.ts @@ -10,4 +10,4 @@ ////} verify.quickInfoAt("", "var M.C.C: typeof M.C"); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/completionListInImportClause04.ts b/tests/cases/fourslash/completionListInImportClause04.ts index fa49b57c8d7..60ec5790120 100644 --- a/tests/cases/fourslash/completionListInImportClause04.ts +++ b/tests/cases/fourslash/completionListInImportClause04.ts @@ -12,6 +12,6 @@ ////import {/*1*/} from './foo'; verify.completionsAt("1", ["prototype", "prop1", "prop2"]); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); goTo.marker('2'); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses.ts b/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses.ts index b46beb8cd53..26c9ca3b096 100644 --- a/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses.ts +++ b/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses.ts @@ -32,4 +32,4 @@ verify.not.completionListContains('bar'); verify.not.completionListContains('baz'); edit.insert('foo;'); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses2.ts b/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses2.ts index f893619244a..73aae2e3596 100644 --- a/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses2.ts +++ b/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses2.ts @@ -35,4 +35,4 @@ verify.not.completionListContains('bar'); verify.not.completionListContains('baz'); edit.insert('foo;'); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/derivedTypeIndexerWithGenericConstraints.ts b/tests/cases/fourslash/derivedTypeIndexerWithGenericConstraints.ts index ad8bbfe6a7f..21489b5d8aa 100644 --- a/tests/cases/fourslash/derivedTypeIndexerWithGenericConstraints.ts +++ b/tests/cases/fourslash/derivedTypeIndexerWithGenericConstraints.ts @@ -25,4 +25,4 @@ ////var result2 = r2.x; verify.quickInfoAt("", "var r: CollectionItem"); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/editLambdaArgToTypeParameter1.ts b/tests/cases/fourslash/editLambdaArgToTypeParameter1.ts index d83d71efa9c..b462e906166 100644 --- a/tests/cases/fourslash/editLambdaArgToTypeParameter1.ts +++ b/tests/cases/fourslash/editLambdaArgToTypeParameter1.ts @@ -10,8 +10,8 @@ goTo.marker('1'); edit.backspace(6); edit.insert('T'); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); goTo.marker('2'); edit.insertLine(''); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/enumUpdate1.ts b/tests/cases/fourslash/enumUpdate1.ts index e7ccfdb5f83..2616396344b 100644 --- a/tests/cases/fourslash/enumUpdate1.ts +++ b/tests/cases/fourslash/enumUpdate1.ts @@ -19,7 +19,7 @@ // If we do not, an error will be raised claiming // that foo's return type is not assignable with // it's signature return type -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); goTo.marker('1'); edit.insert('D = C << 1,'); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/errorsAfterResolvingVariableDeclOfMergedVariableAndClassDecl.ts b/tests/cases/fourslash/errorsAfterResolvingVariableDeclOfMergedVariableAndClassDecl.ts index b98eec4eaf4..2cd351635b3 100644 --- a/tests/cases/fourslash/errorsAfterResolvingVariableDeclOfMergedVariableAndClassDecl.ts +++ b/tests/cases/fourslash/errorsAfterResolvingVariableDeclOfMergedVariableAndClassDecl.ts @@ -10,7 +10,7 @@ //// } ////} -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); // Edit and bind and resolve only var decl goTo.marker("1"); @@ -18,5 +18,4 @@ edit.backspace(1); edit.insert(" "); verify.quickInfoIs("var M.C.C: typeof M.C"); -// Verify there are no errors -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/exportEqualTypes.ts b/tests/cases/fourslash/exportEqualTypes.ts index b03e21b5f99..f130d211031 100644 --- a/tests/cases/fourslash/exportEqualTypes.ts +++ b/tests/cases/fourslash/exportEqualTypes.ts @@ -21,4 +21,4 @@ verify.quickInfos({ }); goTo.marker('4'); verify.completionListContains('foo'); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/extendArrayInterfaceMember.ts b/tests/cases/fourslash/extendArrayInterfaceMember.ts index ef3c06b2053..81fa784082c 100644 --- a/tests/cases/fourslash/extendArrayInterfaceMember.ts +++ b/tests/cases/fourslash/extendArrayInterfaceMember.ts @@ -17,4 +17,4 @@ edit.insert("interface Array { pop(def: T): T; }"); verify.not.errorExistsBetweenMarkers("1", "2"); verify.quickInfoAt("y", "var y: number"); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/extendInterfaceOverloadedMethod.ts b/tests/cases/fourslash/extendInterfaceOverloadedMethod.ts index 0ef8942cded..dd4332c2473 100644 --- a/tests/cases/fourslash/extendInterfaceOverloadedMethod.ts +++ b/tests/cases/fourslash/extendInterfaceOverloadedMethod.ts @@ -12,4 +12,4 @@ ////var /**/x = b.foo2().foo(5).foo(); // 'x' is of type 'void' verify.quickInfoAt("", "var x: void"); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/extendsTArray.ts b/tests/cases/fourslash/extendsTArray.ts index 24482125ca8..8f655b9db45 100644 --- a/tests/cases/fourslash/extendsTArray.ts +++ b/tests/cases/fourslash/extendsTArray.ts @@ -11,4 +11,4 @@ ////y.length; verify.quickInfoAt("", "var y: Date[]"); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/findAllReferencesOfConstructor.ts b/tests/cases/fourslash/findAllReferencesOfConstructor.ts index dcdc23bdc7f..37f0264c816 100644 --- a/tests/cases/fourslash/findAllReferencesOfConstructor.ts +++ b/tests/cases/fourslash/findAllReferencesOfConstructor.ts @@ -41,6 +41,14 @@ ////class d extends a.C { constructor() { [|super|](); } const ranges = test.ranges(); -const [r0, r1, r2] = ranges; -verify.referenceGroups([r0, r2], [{ definition: "constructor C(n: number): C (+1 overload)", ranges }]); -verify.referenceGroups(r1, [{ definition: "constructor C(): C (+1 overload)", ranges }]); +const [a0, a1, a2, a3, a4, b0, c0, d0, d1] = ranges; +verify.referenceGroups([a0, a2], defs("constructor C(n: number): C (+1 overload)")); +verify.referenceGroups(a1, defs("constructor C(): C (+1 overload)")); + +function defs(definition: string) { + return [ + { definition, ranges: [a0, a1, a2, a3, d0, d1, a4] }, + { definition: "import C", ranges: [b0] }, + { definition: "import C", ranges: [c0] } + ] +} diff --git a/tests/cases/fourslash/findAllRefsDefaultImportThroughNamespace.ts b/tests/cases/fourslash/findAllRefsDefaultImportThroughNamespace.ts new file mode 100644 index 00000000000..b282af52ec1 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsDefaultImportThroughNamespace.ts @@ -0,0 +1,20 @@ +/// + +// @Filename: /a.ts +////export default function [|{| "isWriteAccess": true, "isDefinition": true |}f|]() {} + +// @Filename: /b.ts +////export import a = require("./a"); + +// @Filename: /c.ts +////import { a } from "./b"; +////a.[|default|](); + +verify.singleReferenceGroup("function f(): void"); + +const [r0, r1] = test.ranges(); + +verify.rangesAreRenameLocations([r0]); + +goTo.rangeStart(r1); +verify.renameInfoFailed(); diff --git a/tests/cases/fourslash/findAllRefsExportAsNamespace.ts b/tests/cases/fourslash/findAllRefsExportAsNamespace.ts new file mode 100644 index 00000000000..e6b29fce47f --- /dev/null +++ b/tests/cases/fourslash/findAllRefsExportAsNamespace.ts @@ -0,0 +1,24 @@ +/// + +// `export as namespace` results in global search. + +// @Filename: /node_modules/a/index.d.ts +////export function [|{| "isWriteAccess": true, "isDefinition": true |}f|](): void; +////export as namespace A; + +// @Filename: /b.ts +////import { [|{| "isWriteAccess": true, "isDefinition": true |}f|] } from "a"; + +// @Filename: /c.ts +////A.[|f|](); + +verify.noErrors(); + +const ranges = test.ranges(); +const [r0, r1, r2] = ranges; + +const globals = { definition: "function f(): void", ranges: [r0, r2] }; +const imports = { definition: "import f", ranges: [r1] }; + +verify.referenceGroups([r0, r2], [globals, imports]); +verify.referenceGroups(r1, [imports, globals]); diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport.ts b/tests/cases/fourslash/findAllRefsForDefaultExport.ts index c518bb8f59e..61bacdacf90 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExport.ts +++ b/tests/cases/fourslash/findAllRefsForDefaultExport.ts @@ -7,5 +7,12 @@ ////import [|{| "isWriteAccess": true, "isDefinition": true |}g|] from "./a"; /////*ref*/[|g|](); -verify.singleReferenceGroup("function f(): void"); +const ranges = test.ranges(); +const [r0, r1, r2] = ranges; +verify.referenceGroups(r0, [ + { definition: "function f(): void", ranges: [r0] }, + { definition: "import g", ranges: [r1, r2] } +]); +verify.referenceGroups(r1, [{ definition: "import g", ranges: [r1, r2] }]); +verify.referenceGroups(r2, [{ definition: "(alias) g(): void\nimport g", ranges: [r1, r2] }]); verify.goToDefinition("ref", "def"); diff --git a/tests/cases/fourslash/findAllRefsGlobalModuleAugmentation.ts b/tests/cases/fourslash/findAllRefsGlobalModuleAugmentation.ts new file mode 100644 index 00000000000..c2f4982b653 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsGlobalModuleAugmentation.ts @@ -0,0 +1,13 @@ +/// + +// @Filename: /a.ts +////export {}; +////declare global { +//// function [|{| "isWriteAccess": true, "isDefinition": true |}f|](): void; +////} + +// @Filename: /b.ts +////[|f|](); + +verify.noErrors(); +verify.singleReferenceGroup("function f(): void"); diff --git a/tests/cases/fourslash/findAllRefsIII.ts b/tests/cases/fourslash/findAllRefsIII.ts new file mode 100644 index 00000000000..99a5ba55719 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsIII.ts @@ -0,0 +1,16 @@ +/// + +// @Filename: /a.ts +////function [|{| "isWriteAccess": true, "isDefinition": true |}f|]() {}; +////export { [|{| "isWriteAccess": true, "isDefinition": true |}f|] as [|{| "isWriteAccess": true, "isDefinition": true |}g|] }; + +// @Filename: /b.ts +////import { [|{| "isWriteAccess": true, "isDefinition": true |}g|] } from "./a"; + +verify.noErrors(); +const [f0, f1, g0, g1] = test.ranges(); + +const fs = { definition: "function f(): void", ranges: [f0, f1] }; +const gs0 = { definition: "import g", ranges: [g0] }; +const gs1 = { definition: "import g", ranges: [g1] }; +verify.referenceGroups(f0, [fs, gs0, gs1]); diff --git a/tests/cases/fourslash/findAllRefsImportStarOfExportEquals.ts b/tests/cases/fourslash/findAllRefsImportStarOfExportEquals.ts new file mode 100644 index 00000000000..c57f4a67fda --- /dev/null +++ b/tests/cases/fourslash/findAllRefsImportStarOfExportEquals.ts @@ -0,0 +1,60 @@ +/// + +// @Filename: /node_modules/a/index.d.ts +////declare function [|{| "isWriteAccess": true, "isDefinition": true |}a|](): void; +////declare namespace [|{| "isWriteAccess": true, "isDefinition": true |}a|] { +//// export const x: number; +////} +////export = [|a|]; + +// Import with different name and we find local refs +// @Filename: /b.ts +////import * as [|{| "isWriteAccess": true, "isDefinition": true |}b|] from "a"; +////[|b|](); +////[|b|].x; + +// Import with same name and we find all refs +// @Filename: /c.ts +////import * as [|{| "isWriteAccess": true, "isDefinition": true |}a|] from "a"; +////[|a|](); +////[|a|].x; + +verify.noErrors(); +const ranges = test.ranges(); +const [a0, a1, a2, b0, b1, b2, c0, c1, c2] = ranges; +const aRanges = [a0, a1, a2]; +const bRanges = [b0, b1, b2]; +const cRanges = [c0, c1, c2]; + +verify.referenceGroups(a0, [ + { definition: "function a(): void\nnamespace a", ranges: aRanges }, + { definition: "import b", ranges: bRanges }, + { definition: "import a", ranges: cRanges } +]); +verify.referenceGroups([a1, a2], [ + { definition: "namespace a\nfunction a(): void", ranges: aRanges }, + { definition: "import b", ranges: bRanges }, + { definition: "import a", ranges: cRanges } +]); + +verify.referenceGroups([b0, b0], [ + { definition: "import b", ranges: bRanges } +]); +verify.referenceGroups(b1, [ + { definition: "(alias) b(): void\nimport b", ranges: bRanges } +]); + +verify.referenceGroups([c0, c2], [ + { definition: "import a", ranges: cRanges }, + { definition: "namespace a\nfunction a(): void", ranges: aRanges }, + { definition: "import b", ranges: bRanges } +]); +verify.referenceGroups(c1, [ + { definition: "(alias) a(): void\nimport a", ranges: cRanges }, + { definition: "namespace a\nfunction a(): void", ranges: aRanges }, + { definition: "import b", ranges: bRanges } +]); + +verify.renameLocations(aRanges, aRanges.concat(cRanges)); +verify.rangesAreRenameLocations(bRanges); +verify.rangesAreRenameLocations(cRanges); diff --git a/tests/cases/fourslash/findAllRefsModuleAugmentation.ts b/tests/cases/fourslash/findAllRefsModuleAugmentation.ts new file mode 100644 index 00000000000..c5adab35669 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsModuleAugmentation.ts @@ -0,0 +1,13 @@ +/// + +// @Filename: /node_modules/foo/index.d.ts +////export type [|{| "isWriteAccess": true, "isDefinition": true |}T|] = number; + +// @Filename: /a.ts +////import * as foo from "foo"; +////declare module "foo" { +//// export const x: [|T|]; +////} + +verify.noErrors(); +verify.singleReferenceGroup("type T = number"); diff --git a/tests/cases/fourslash/findAllRefsOnDefinition2.ts b/tests/cases/fourslash/findAllRefsOnDefinition2.ts index 6d2438a124c..0212d12a3be 100644 --- a/tests/cases/fourslash/findAllRefsOnDefinition2.ts +++ b/tests/cases/fourslash/findAllRefsOnDefinition2.ts @@ -18,4 +18,3 @@ const ranges = test.ranges(); const [r0, r1] = ranges; verify.referenceGroups(r0, [{ definition: "interface Test.start", ranges }]); verify.referenceGroups(r1, [{ definition: "interface Second.Test.start", ranges }]); - diff --git a/tests/cases/fourslash/findAllRefsOnImportAliases.ts b/tests/cases/fourslash/findAllRefsOnImportAliases.ts index 7574e11625f..98509ad6938 100644 --- a/tests/cases/fourslash/findAllRefsOnImportAliases.ts +++ b/tests/cases/fourslash/findAllRefsOnImportAliases.ts @@ -14,5 +14,13 @@ const ranges = test.ranges(); const [r0, r1, r2, r3] = ranges; -verify.referenceGroups([r0, r1, r3], [{ definition: "class Class", ranges }]); -verify.referenceGroups(r2, [{ definition: "constructor Class(): Class", ranges }]); +const classes = { definition: "class Class", ranges: [r0] }; +const imports = { definition: "import Class", ranges: [r1, r2] }; +const reExports = { definition: "import Class", ranges: [r3] }; +verify.referenceGroups(r0, [classes, imports, reExports]); +verify.referenceGroups(r1, [imports, classes, reExports]); +verify.referenceGroups(r2, [ + { definition: "(alias) new Class(): Class\nimport Class", ranges: [r1, r2] }, + classes, + reExports +]); diff --git a/tests/cases/fourslash/findAllRefsOnImportAliases2.ts b/tests/cases/fourslash/findAllRefsOnImportAliases2.ts index a21d2da4c03..63fb12f5270 100644 --- a/tests/cases/fourslash/findAllRefsOnImportAliases2.ts +++ b/tests/cases/fourslash/findAllRefsOnImportAliases2.ts @@ -13,11 +13,20 @@ ////export { [|{| "isWriteAccess": true, "isDefinition": true |}Class|] as [|{| "isWriteAccess": true, "isDefinition": true |}C3|] } from "./a"; const ranges = test.rangesByText(); -verify.singleReferenceGroup("class Class", ranges.get("Class")); +const classRanges = ranges.get("Class"); +const [class0, class1, class2] = classRanges; +const c2Ranges = ranges.get("C2"); +const [c2_0, c2_1] = c2Ranges; +const c3Ranges = ranges.get("C3"); +const classes = { definition: "class Class", ranges: classRanges }; +const c2s = { definition: "import C2", ranges: c2Ranges }; +const c3s = { definition: "import C3", ranges: c3Ranges }; -const c2s = ranges.get("C2"); -const [c2_0, c2_1] = c2s; -verify.referenceGroups(c2_0, [{ definition: "import C2", ranges: c2s }]); -verify.referenceGroups(c2_1, [{ definition: "(alias) new C2(): C2\nimport C2", ranges: c2s }]); +verify.referenceGroups(classRanges, [classes, c2s, c3s]); -verify.singleReferenceGroup("import C3", ranges.get("C3")); +verify.referenceGroups(c2_0, [c2s]) +verify.referenceGroups(c2_1, [{ definition: "(alias) new C2(): C2\nimport C2", ranges: c2Ranges }]); + +verify.referenceGroups(c3Ranges, [c3s]); + +verify.rangesWithSameTextAreRenameLocations(); diff --git a/tests/cases/fourslash/findAllRefsReExportLocal.ts b/tests/cases/fourslash/findAllRefsReExportLocal.ts new file mode 100644 index 00000000000..25e8accbbc0 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsReExportLocal.ts @@ -0,0 +1,30 @@ +/// + +// @noLib: true + +// @Filename: /a.ts +////var [|{| "isWriteAccess": true, "isDefinition": true |}x|]; +////export { [|{| "isWriteAccess": true, "isDefinition": true |}x|] }; +////export { [|{| "isWriteAccess": true, "isDefinition": true |}x|] as [|{| "isWriteAccess": true, "isDefinition": true |}y|] }; + +// @Filename: /b.ts +////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|], [|{| "isWriteAccess": true, "isDefinition": true |}y|] } from "./a"; +////[|x|]; [|y|]; + +verify.noErrors(); + +const [ax0, ax1, ax2, ay, bx0, by0, bx1, by1] = test.ranges(); +const axRanges = [ax0, ax1, ax2]; +const bxRanges = [bx0, bx1]; +const byRanges = [by0, by1]; +const axGroup = { definition: "var x: any", ranges: axRanges }; +const bxGroup = { definition: "import x", ranges: bxRanges }; +const ayGroup = { definition: "import y", ranges: [ay] } +const byGroup = { definition: "import y", ranges: byRanges } + +verify.referenceGroups(axRanges, [axGroup, bxGroup, ayGroup, byGroup]); +verify.referenceGroups(bxRanges, [bxGroup, axGroup, ayGroup, byGroup]); +verify.referenceGroups(ay, [ayGroup, byGroup]); +verify.referenceGroups(byRanges, [byGroup, ayGroup]); + +verify.rangesWithSameTextAreRenameLocations(); diff --git a/tests/cases/fourslash/findAllRefsReExportStar.ts b/tests/cases/fourslash/findAllRefsReExportStar.ts new file mode 100644 index 00000000000..86901cfadf2 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsReExportStar.ts @@ -0,0 +1,18 @@ +/// + +// @Filename: /a.ts +////export function [|{| "isWriteAccess": true, "isDefinition": true |}foo|](): void {} + +// @Filename: /b.ts +////export * from "./a"; + +// @Filename: /c.ts +////import { [|{| "isWriteAccess": true, "isDefinition": true |}foo|] } from "./b"; + +verify.noErrors(); +const ranges = test.ranges(); +const [r0, r1] = ranges; +const a = { definition: "function foo(): void", ranges: [r0] }; +const c = { definition: "import foo", ranges: [r1] }; +verify.referenceGroups(r0, [a, c]); +verify.referenceGroups(r1, [c, a]); diff --git a/tests/cases/fourslash/findAllRefsReExports.ts b/tests/cases/fourslash/findAllRefsReExports.ts new file mode 100644 index 00000000000..593db568c8a --- /dev/null +++ b/tests/cases/fourslash/findAllRefsReExports.ts @@ -0,0 +1,61 @@ +/// + +// @Filename: /a.ts +////export function [|{| "isWriteAccess": true, "isDefinition": true |}foo|](): void {} + +// @Filename: /b.ts +////export { [|{| "isWriteAccess": true, "isDefinition": true |}foo|] as [|{| "isWriteAccess": true, "isDefinition": true |}bar|] } from "./a"; + +// @Filename: /c.ts +////export { [|{| "isWriteAccess": true, "isDefinition": true |}foo|] as [|{| "isWriteAccess": true, "isDefinition": true |}default|] } from "./a"; + +// @Filename: /d.ts +////export { [|{| "isWriteAccess": true, "isDefinition": true |}default|] } from "./c"; + +// @Filename: /e.ts +////import { [|{| "isWriteAccess": true, "isDefinition": true |}bar|] } from "./b"; +////import [|{| "isWriteAccess": true, "isDefinition": true |}baz|] from "./c"; +////import { [|{| "isWriteAccess": true, "isDefinition": true |}default|] as [|{| "isWriteAccess": true, "isDefinition": true |}bang|] } from "./c"; +////import [|{| "isWriteAccess": true, "isDefinition": true |}boom|] from "./d"; +////[|bar|](); [|baz|](); [|bang|](); [|boom|](); + +verify.noErrors(); +const [foo0, foo1, bar0, foo2, defaultC, defaultD, bar1, baz0, defaultE, bang0, boom0, bar2, baz1, bang1, boom1] = test.ranges(); +const a = { definition: "function foo(): void", ranges: [foo0, foo1, foo2] }; +const b = { definition: "import bar", ranges: [bar0] }; +const c = { definition: "import default", ranges: [defaultC, defaultE] }; +const d = { definition: "import default", ranges: [defaultD] }; +const eBar = { definition: "import bar", ranges: [bar1, bar2] }; +const eBaz = { definition: "import baz", ranges: [baz0, baz1] }; +const eBang = { definition: "import bang", ranges: [bang0, bang1] }; +const eBoom = { definition: "import boom", ranges: [boom0, boom1] }; + +verify.referenceGroups([foo0, foo1, foo2], [a, b, eBar, c, d, eBoom, eBaz, eBang]); + +verify.referenceGroups(bar0, [b, eBar]); +verify.referenceGroups(bar1, [eBar, b]); +verify.referenceGroups(bar2, [{ ...eBar, definition: "(alias) bar(): void\nimport bar" }, b]); + +verify.referenceGroups([defaultC], [c, d, eBoom, eBaz, eBang]); +verify.referenceGroups(defaultD, [d, eBoom, a, b, eBar,c, eBaz, eBang]); +verify.referenceGroups(defaultE, [c, d, eBoom, eBaz, eBang]); +verify.referenceGroups(baz0, [eBaz]); +verify.referenceGroups(baz1, [{ ...eBaz, definition: "(alias) baz(): void\nimport baz" }]); + +verify.referenceGroups(bang0, [eBang]); +verify.referenceGroups(bang1, [{ ...eBang, definition: "(alias) bang(): void\nimport bang" }]); + +verify.referenceGroups(boom0, [eBoom]); +verify.referenceGroups(boom1, [{ ...eBoom, definition: "(alias) boom(): void\nimport boom" }]); + +test.rangesByText().forEach((ranges, text) => { + if (text === "default") { + for (const range of ranges) { + goTo.rangeStart(defaultC); + verify.renameInfoFailed(); + } + } + else { + verify.rangesAreRenameLocations(ranges); + } +}); diff --git a/tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment.ts b/tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment.ts index 544a3238e3b..0c6f088d06b 100644 --- a/tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment.ts +++ b/tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment.ts @@ -7,7 +7,7 @@ //// obj.[|name|]; const [r0, r1, r2, r3, r4] = test.ranges(); -verify.referenceGroups([r0, r3], [{ definition: "var name: string", ranges: [r0, r1, r3] }]); +verify.referenceGroups(r0, [{ definition: "var name: string", ranges: [r0, r1, r3] }]); //r3 verify.referenceGroups(r1, [ { definition: "var name: string", ranges: [r0, r3] }, { definition: "(property) name: string", ranges: [r1, r4] } diff --git a/tests/cases/fourslash/findReferencesJSXTagName.ts b/tests/cases/fourslash/findReferencesJSXTagName.ts index 5f8bc3a475f..740eb395b3c 100644 --- a/tests/cases/fourslash/findReferencesJSXTagName.ts +++ b/tests/cases/fourslash/findReferencesJSXTagName.ts @@ -13,4 +13,7 @@ const ranges = test.ranges(); const [r0, r1, r2] = ranges; -verify.referenceGroups(ranges, [{ definition: "const SubmissionComp: (submission: any) => any", ranges: [r2, r0, r1] }]); +const imports = { definition: "import SubmissionComp", ranges: [r0, r1] }; +const def = { definition: "const SubmissionComp: (submission: any) => any", ranges: [r2] }; +verify.referenceGroups([r0, r1], [imports, def]); +verify.referenceGroups(r2, [def, imports]); diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts index 661d7cba6a4..633c471f00e 100644 --- a/tests/cases/fourslash/fourslash.ts +++ b/tests/cases/fourslash/fourslash.ts @@ -183,6 +183,7 @@ declare namespace FourSlashInterface { verifyGetEmitOutputForCurrentFile(expected: string): void; verifyGetEmitOutputContentsForCurrentFile(expected: ts.OutputFile[]): void; noReferences(markerNameOrRange?: string | Range): void; + symbolAtLocation(startRange: Range, ...declarationRanges: Range[]): void; /** * @deprecated, prefer 'referenceGroups' * Like `referencesAre`, but goes to `start` first. @@ -196,7 +197,8 @@ declare namespace FourSlashInterface { referenceGroups(startRanges: Range | Range[], parts: Array<{ definition: string, ranges: Range[] }>): void; singleReferenceGroup(definition: string, ranges?: Range[]): void; rangesAreOccurrences(isWriteAccess?: boolean): void; - rangesAreRenameLocations(findInStrings?: boolean, findInComments?: boolean): void; + rangesWithSameTextAreRenameLocations(): void; + rangesAreRenameLocations(options?: Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges?: Range[] }); /** * Performs `referencesOf` for every range on the whole set. * If `ranges` is omitted, this is `test.ranges()`. @@ -213,6 +215,8 @@ declare namespace FourSlashInterface { currentSignatureParameterCountIs(expected: number): void; currentSignatureTypeParameterCountIs(expected: number): void; currentSignatureHelpIs(expected: string): void; + // Checks that there are no compile errors. + noErrors(): void; numberOfErrorsInCurrentFile(expected: number): void; baselineCurrentFileBreakpointLocations(): void; baselineCurrentFileNameOrDottedNameSpans(): void; @@ -254,7 +258,7 @@ declare namespace FourSlashInterface { }[]): void; renameInfoSucceeded(displayName?: string, fullDisplayName?: string, kind?: string, kindModifiers?: string): void; renameInfoFailed(message?: string): void; - renameLocations(findInStrings: boolean, findInComments: boolean, ranges?: Range[]): void; + renameLocations(startRanges: Range | Range[], options: Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges: Range[] }): void; /** Verify the quick info available at the current marker. */ quickInfoIs(expectedText: string, expectedDocumentation?: string): void; diff --git a/tests/cases/fourslash/functionTypes.ts b/tests/cases/fourslash/functionTypes.ts index 813dfa8cdcb..fdcb924af98 100644 --- a/tests/cases/fourslash/functionTypes.ts +++ b/tests/cases/fourslash/functionTypes.ts @@ -20,7 +20,7 @@ ////typeof C.k./*6*/caller === 'function'; ////l./*7*/prototype = Object.prototype; -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); for (var i = 1; i <= 7; i++) { goTo.marker('' + i); verify.completionListCount(8); diff --git a/tests/cases/fourslash/funduleWithRecursiveReference.ts b/tests/cases/fourslash/funduleWithRecursiveReference.ts index aa0b549965a..6291131acb0 100644 --- a/tests/cases/fourslash/funduleWithRecursiveReference.ts +++ b/tests/cases/fourslash/funduleWithRecursiveReference.ts @@ -8,4 +8,4 @@ ////} verify.quickInfoAt("", "var M.C.C: typeof M.C"); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/genericInterfacePropertyInference1.ts b/tests/cases/fourslash/genericInterfacePropertyInference1.ts index 00344988a72..60f4cf0dda3 100644 --- a/tests/cases/fourslash/genericInterfacePropertyInference1.ts +++ b/tests/cases/fourslash/genericInterfacePropertyInference1.ts @@ -20,7 +20,7 @@ //// ofT: T; //// ofFooNum: Foo; //// ofInterface: I; -//// ofIG4: { x: number }; +//// ofIG4: { x: number }; //// ofIG6: { x: T }; //// ofC2: C; //// ofC4: C<{ x: T }> @@ -35,33 +35,33 @@ ////// T is any ////var f_/*a1*/r1 = f.prim1; ////var f_/*a2*/r2 = f.prim2; -////var f_/*a3*/r3 = f.ofT; +////var f_/*a3*/r3 = f.ofT; ////var f_/*a4*/r5 = f.ofFooNum; ////var f_/*a5*/r8 = f.ofInterface; ////var f_/*a6*/r12 = f.ofIG4; -////var f_/*a7*/r14 = f.ofIG6; +////var f_/*a7*/r14 = f.ofIG6; ////var f_/*a8*/r18 = f.ofC2; -////var f_/*a9*/r20 = f.ofC4; +////var f_/*a9*/r20 = f.ofC4; //// ////// T is number ////var f2_/*b1*/r1 = f2.prim1; ////var f2_/*b2*/r2 = f2.prim2; -////var f2_/*b3*/r3 = f2.ofT; -////var f2_/*b4*/r5 = f2.ofFooNum; +////var f2_/*b3*/r3 = f2.ofT; +////var f2_/*b4*/r5 = f2.ofFooNum; ////var f2_/*b5*/r8 = f2.ofInterface; ////var f2_/*b6*/r12 = f2.ofIG4; -////var f2_/*b7*/r14 = f2.ofIG6; +////var f2_/*b7*/r14 = f2.ofIG6; ////var f2_/*b8*/r18 = f2.ofC2; -////var f2_/*b9*/r20 = f2.ofC4; +////var f2_/*b9*/r20 = f2.ofC4; //// ////// T is I ////var f3_/*c1*/r1 = f3.prim1; ////var f3_/*c2*/r2 = f3.prim2; -////var f3_/*c3*/r3 = f3.ofT; +////var f3_/*c3*/r3 = f3.ofT; ////var f3_/*c4*/r5 = f3.ofFooNum; ////var f3_/*c5*/r8 = f3.ofInterface; ////var f3_/*c6*/r12 = f3.ofIG4; -////var f3_/*c7*/r14 = f3.ofIG6; +////var f3_/*c7*/r14 = f3.ofIG6; ////var f3_/*c8*/r18 = f3.ofC2; ////var f3_/*c9*/r20 = f3.ofC4; //// @@ -74,20 +74,20 @@ ////var f4_/*d6*/r12 = f4.ofIG4; ////var f4_/*d7*/r14 = f4.ofIG6; ////var f4_/*d8*/r18 = f4.ofC2; -////var f4_/*d9*/r20 = f4.ofC4; +////var f4_/*d9*/r20 = f4.ofC4; //// ////// T is Foo ////var f5_/*e1*/r1 = f5.prim1; ////var f5_/*e2*/r2 = f5.prim2; -////var f5_/*e3*/r3 = f5.ofT; +////var f5_/*e3*/r3 = f5.ofT; ////var f5_/*e4*/r5 = f5.ofFooNum; ////var f5_/*e5*/r8 = f5.ofInterface; ////var f5_/*e6*/r12 = f5.ofIG4; -////var f5_/*e7*/r14 = f5.ofIG6; +////var f5_/*e7*/r14 = f5.ofIG6; ////var f5_/*e8*/r18 = f5.ofC2; ////var f5_/*e9*/r20 = f5.ofC4; -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); verify.quickInfos({ "a1": "var f_r1: number", diff --git a/tests/cases/fourslash/genericInterfacePropertyInference2.ts b/tests/cases/fourslash/genericInterfacePropertyInference2.ts index 1da115e595b..a3600865a9e 100644 --- a/tests/cases/fourslash/genericInterfacePropertyInference2.ts +++ b/tests/cases/fourslash/genericInterfacePropertyInference2.ts @@ -32,7 +32,7 @@ ////var f_/*a1*/r4 = f.ofFooT; ////var f_/*a2*/r7 = f.ofFooFooNum; ////var f_/*a3*/r9 = f.ofIG; -////var f_/*a5*/r13 = f.ofIG5; +////var f_/*a5*/r13 = f.ofIG5; ////var f_/*a7*/r17 = f.ofC1; //// ////// T is number @@ -60,10 +60,10 @@ ////var f5_/*e1*/r4 = f5.ofFooT; ////var f5_/*e2*/r7 = f5.ofFooFooNum; ////var f5_/*e3*/r9 = f5.ofIG; -////var f5_/*e5*/r13 = f5.ofIG5; +////var f5_/*e5*/r13 = f5.ofIG5; ////var f5_/*e7*/r17 = f5.ofC1; -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); verify.quickInfos({ a1: "var f_r4: Foo", diff --git a/tests/cases/fourslash/genericInterfaceWithInheritanceEdit1.ts b/tests/cases/fourslash/genericInterfaceWithInheritanceEdit1.ts index f2b685937ea..36ca3bb57f8 100644 --- a/tests/cases/fourslash/genericInterfaceWithInheritanceEdit1.ts +++ b/tests/cases/fourslash/genericInterfaceWithInheritanceEdit1.ts @@ -8,12 +8,12 @@ //// value(): T; ////} ////interface ChainedArray extends ChainedObject> { -//// +//// //// extend(...sources: any[]): ChainedArray; ////} //// /*1*/ -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); goTo.marker('1'); edit.insert(' '); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/genericMapTyping1.ts b/tests/cases/fourslash/genericMapTyping1.ts index 20e08d3f53d..2af3ec537c4 100644 --- a/tests/cases/fourslash/genericMapTyping1.ts +++ b/tests/cases/fourslash/genericMapTyping1.ts @@ -20,7 +20,7 @@ ////var c/*5*/cc = _(aaa).map(xx => xx.length); // Should not error, should be any[] ////var d/*6*/dd = aaa.map(xx => xx.length); // should not error, should be any[] -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); verify.quickInfos({ 1: "var bb: number[]", 2: "var cc: number[]", diff --git a/tests/cases/fourslash/genericMethodParam.ts b/tests/cases/fourslash/genericMethodParam.ts index 7e8bf916b6c..a7ee60b3ded 100644 --- a/tests/cases/fourslash/genericMethodParam.ts +++ b/tests/cases/fourslash/genericMethodParam.ts @@ -5,14 +5,14 @@ //// } //// /*2*/ -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); goTo.marker('1'); edit.insertLine("constructor(){}"); edit.insertLine("foo(a: T) {"); edit.insertLine(" return a;"); edit.insertLine("}"); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); goTo.marker('2'); edit.insertLine("var x = new C();"); edit.insertLine("var y: number = x.foo(5);"); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/genericObjectBaseType.ts b/tests/cases/fourslash/genericObjectBaseType.ts index de0f508d0f0..acca6c3c33b 100644 --- a/tests/cases/fourslash/genericObjectBaseType.ts +++ b/tests/cases/fourslash/genericObjectBaseType.ts @@ -11,4 +11,4 @@ //// /*1*/ goTo.marker('1'); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/genericRespecialization1.ts b/tests/cases/fourslash/genericRespecialization1.ts index e8db5eafc4a..3264052aea9 100644 --- a/tests/cases/fourslash/genericRespecialization1.ts +++ b/tests/cases/fourslash/genericRespecialization1.ts @@ -63,13 +63,13 @@ //// } //// /*1*/ -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); goTo.marker('1'); edit.insertLine(''); edit.insertLine(''); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); goTo.marker('2'); edit.deleteAtCaret("Cookie".length); edit.insert("any"); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); edit.insertLine('var narnia = new GenericPlanet2('); // shouldn't crash at this point \ No newline at end of file diff --git a/tests/cases/fourslash/genericTypeArgumentInference1.ts b/tests/cases/fourslash/genericTypeArgumentInference1.ts index 63c93628b47..5d4d38c4865 100644 --- a/tests/cases/fourslash/genericTypeArgumentInference1.ts +++ b/tests/cases/fourslash/genericTypeArgumentInference1.ts @@ -30,4 +30,4 @@ verify.quickInfos({ 4: "var r4: any", 41: "(method) Underscore.Static.all(list: any[], iterator?: Underscore.Iterator, context?: any): any" }); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/genericTypeArgumentInference2.ts b/tests/cases/fourslash/genericTypeArgumentInference2.ts index 6b55b11f03a..a93e5ac6ea5 100644 --- a/tests/cases/fourslash/genericTypeArgumentInference2.ts +++ b/tests/cases/fourslash/genericTypeArgumentInference2.ts @@ -30,4 +30,4 @@ verify.quickInfos({ 4: "var r4: any", 41: "(method) Underscore.Static.all(list: any[], iterator?: Underscore.Iterator, context?: any): any" }); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts b/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts index 9cdfb0aa0f7..4268e5d180d 100644 --- a/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts +++ b/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts @@ -5,4 +5,9 @@ ////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./m"; ////const y = [|x|]; -verify.singleReferenceGroup("var x: number"); +const ranges = test.ranges(); +const [r0, r1, r2] = ranges; +const defs = { definition: "var x: number", ranges: [r0] }; +const imports = { definition: "import x", ranges: [r1, r2] }; +verify.referenceGroups(r0, [defs, imports]); +verify.referenceGroups([r1, r2], [imports, defs]); diff --git a/tests/cases/fourslash/getSemanticDiagnosticForDeclaration1.ts b/tests/cases/fourslash/getSemanticDiagnosticForDeclaration1.ts index 13a2dccfd26..9e990dddbfc 100644 --- a/tests/cases/fourslash/getSemanticDiagnosticForDeclaration1.ts +++ b/tests/cases/fourslash/getSemanticDiagnosticForDeclaration1.ts @@ -4,6 +4,4 @@ // @Filename: File.d.ts //// declare var v: string; -verify.numberOfErrorsInCurrentFile(0); - - +verify.noErrors(); diff --git a/tests/cases/fourslash/getSemanticDiagnosticForNoDeclaration.ts b/tests/cases/fourslash/getSemanticDiagnosticForNoDeclaration.ts index cdcde01054e..917d394601f 100644 --- a/tests/cases/fourslash/getSemanticDiagnosticForNoDeclaration.ts +++ b/tests/cases/fourslash/getSemanticDiagnosticForNoDeclaration.ts @@ -5,6 +5,6 @@ //// interface privateInterface {} //// export class Bar implements /*1*/privateInterface/*2*/{ } -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/goToImplementationInterfaceMethod_00.ts b/tests/cases/fourslash/goToImplementationInterfaceMethod_00.ts index 38afd0cfb3d..7ec63c4e94b 100644 --- a/tests/cases/fourslash/goToImplementationInterfaceMethod_00.ts +++ b/tests/cases/fourslash/goToImplementationInterfaceMethod_00.ts @@ -22,4 +22,4 @@ //// } verify.allRangesAppearInImplementationList("function_call"); -verify.allRangesAppearInImplementationList("declaration"); \ No newline at end of file +verify.allRangesAppearInImplementationList("declaration"); diff --git a/tests/cases/fourslash/incrementalUpdateToClassImplementingGenericClass.ts b/tests/cases/fourslash/incrementalUpdateToClassImplementingGenericClass.ts index f8dcc0a1f39..b3724c6e40d 100644 --- a/tests/cases/fourslash/incrementalUpdateToClassImplementingGenericClass.ts +++ b/tests/cases/fourslash/incrementalUpdateToClassImplementingGenericClass.ts @@ -16,7 +16,7 @@ goTo.marker('1'); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); edit.insert("//"); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/javaScriptClass2.ts b/tests/cases/fourslash/javaScriptClass2.ts index d6daa320c5a..dcdac24c7b8 100644 --- a/tests/cases/fourslash/javaScriptClass2.ts +++ b/tests/cases/fourslash/javaScriptClass2.ts @@ -7,16 +7,11 @@ //// class Foo { //// constructor() { //// this.[|union|] = 'foo'; -//// this./*1*/[|union|] = 100; +//// this.[|union|] = 100; //// } -//// method() { return this./*2*/[|union|]; } +//// method() { return this.[|union|]; } //// } //// var x = new Foo(); -//// x./*3*/[|union|]; +//// x.[|union|]; -goTo.marker('1'); -verify.renameLocations(/*findInStrings*/false, /*findInComments*/false); -goTo.marker('2'); -verify.renameLocations(/*findInStrings*/false, /*findInComments*/false); -goTo.marker('3'); -verify.renameLocations(/*findInStrings*/false, /*findInComments*/false); +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/javascriptModules22.ts b/tests/cases/fourslash/javascriptModules22.ts index 89fa99b5ea2..caa8c6798b1 100644 --- a/tests/cases/fourslash/javascriptModules22.ts +++ b/tests/cases/fourslash/javascriptModules22.ts @@ -29,4 +29,4 @@ verify.completionListContains("name"); edit.insert("name;\nsausages."); verify.completionListContains("eggs"); edit.insert("eggs;"); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/jsDocFunctionSignatures4.ts b/tests/cases/fourslash/jsDocFunctionSignatures4.ts index e2b443d8d40..634eb312ff5 100644 --- a/tests/cases/fourslash/jsDocFunctionSignatures4.ts +++ b/tests/cases/fourslash/jsDocFunctionSignatures4.ts @@ -7,5 +7,4 @@ //// * @param {function (string):void} y */ //// function fn(x, y) { } -verify.numberOfErrorsInCurrentFile(0); - +verify.noErrors(); diff --git a/tests/cases/fourslash/jsxSpreadReference.ts b/tests/cases/fourslash/jsxSpreadReference.ts index 595549967e6..915dbdcecdf 100644 --- a/tests/cases/fourslash/jsxSpreadReference.ts +++ b/tests/cases/fourslash/jsxSpreadReference.ts @@ -18,6 +18,4 @@ //// var x = ; verify.goToDefinition("src", "dst"); - -goTo.marker('src'); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/memberConstructorEdits.ts b/tests/cases/fourslash/memberConstructorEdits.ts index 45d631cd2b8..c1cf9507d6e 100644 --- a/tests/cases/fourslash/memberConstructorEdits.ts +++ b/tests/cases/fourslash/memberConstructorEdits.ts @@ -10,17 +10,17 @@ //// return this.m(0); //// } //// } -//// export class B extends A { +//// export class B extends A { //// constructor(a: string) { //// super(a); //// } -//// /*1*/ +//// /*1*/ //// } //// var a = new A("s"); //// var b = new B("s"); //// } -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); goTo.marker('1'); edit.insert("public m(n: number) { return 0; }"); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); diff --git a/tests/cases/fourslash/memberOverloadEdits.ts b/tests/cases/fourslash/memberOverloadEdits.ts index 43553a81179..68972235c5f 100644 --- a/tests/cases/fourslash/memberOverloadEdits.ts +++ b/tests/cases/fourslash/memberOverloadEdits.ts @@ -12,7 +12,7 @@ //// export class B extends A { /*1*/ } //// } -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); goTo.marker('1'); edit.insert("public m(n: number) { return 0; }"); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/moduleReferenceValue.ts b/tests/cases/fourslash/moduleReferenceValue.ts index cce06ad1e1b..a5a4bc7366e 100644 --- a/tests/cases/fourslash/moduleReferenceValue.ts +++ b/tests/cases/fourslash/moduleReferenceValue.ts @@ -17,7 +17,7 @@ //// r4 = x; // 3 ////} -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); verify.eval("r1", undefined); verify.eval("r2", 2); verify.eval("r3", 2); diff --git a/tests/cases/fourslash/multiModuleClodule1.ts b/tests/cases/fourslash/multiModuleClodule1.ts index 0cec8373fb7..5aeb2e709f5 100644 --- a/tests/cases/fourslash/multiModuleClodule1.ts +++ b/tests/cases/fourslash/multiModuleClodule1.ts @@ -39,4 +39,4 @@ verify.completionListContains('x'); verify.completionListContains('foo'); verify.completionListContains('boo'); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/multiModuleFundule1.ts b/tests/cases/fourslash/multiModuleFundule1.ts index 47cb44dedbf..71fd64771d6 100644 --- a/tests/cases/fourslash/multiModuleFundule1.ts +++ b/tests/cases/fourslash/multiModuleFundule1.ts @@ -30,4 +30,4 @@ verify.completionListContains('x'); verify.completionListContains('foo'); edit.insert('x;'); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/parenthesisFatArrows.ts b/tests/cases/fourslash/parenthesisFatArrows.ts index 1751e50afc8..ea123b986e4 100644 --- a/tests/cases/fourslash/parenthesisFatArrows.ts +++ b/tests/cases/fourslash/parenthesisFatArrows.ts @@ -6,6 +6,6 @@ ////(y) => y; ////x => x; -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); verify.not.errorExistsBeforeMarker(); verify.not.errorExistsAfterMarker(); \ No newline at end of file diff --git a/tests/cases/fourslash/quickInfoMeaning.ts b/tests/cases/fourslash/quickInfoMeaning.ts index 414fcc0c86d..a3b9f988e1d 100644 --- a/tests/cases/fourslash/quickInfoMeaning.ts +++ b/tests/cases/fourslash/quickInfoMeaning.ts @@ -18,7 +18,7 @@ ////const x = foo/*foo_value*/; ////const i: foo/*foo_type*/ = { x: 1, y: 2 }; -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); verify.navigationItemsListCount(2, "foo", "exact"); verify.navigationItemsListContains("foo", "alias", "foo", "exact"); @@ -49,7 +49,6 @@ verify.goToDefinitionIs("foo_type_declaration"); ////const x = bar/*bar_value*/; ////const i: bar/*bar_type*/ = { x: 1, y: 2 }; -verify.numberOfErrorsInCurrentFile(0); verify.navigationItemsListCount(2, "bar", "exact"); verify.navigationItemsListContains("bar", "alias", "bar", "exact"); verify.navigationItemsListContains("bar", "interface", "bar", "exact"); diff --git a/tests/cases/fourslash/quickInfoOnMergedInterfacesWithIncrementalEdits.ts b/tests/cases/fourslash/quickInfoOnMergedInterfacesWithIncrementalEdits.ts index 78e39338193..d74883b982d 100644 --- a/tests/cases/fourslash/quickInfoOnMergedInterfacesWithIncrementalEdits.ts +++ b/tests/cases/fourslash/quickInfoOnMergedInterfacesWithIncrementalEdits.ts @@ -23,4 +23,4 @@ edit.insert('a'); verify.quickInfoIs("(property) B.bar: string"); goTo.marker('2'); verify.quickInfoIs("var r4: string"); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/quickInfoOnMergedModule.ts b/tests/cases/fourslash/quickInfoOnMergedModule.ts index 03dd13e823e..6d170d2ec3c 100644 --- a/tests/cases/fourslash/quickInfoOnMergedModule.ts +++ b/tests/cases/fourslash/quickInfoOnMergedModule.ts @@ -16,4 +16,4 @@ ////} verify.quickInfoAt("1", "(property) M2.A.foo: string", undefined); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); diff --git a/tests/cases/fourslash/referencesForAmbients2.ts b/tests/cases/fourslash/referencesForAmbients2.ts new file mode 100644 index 00000000000..8654d90f854 --- /dev/null +++ b/tests/cases/fourslash/referencesForAmbients2.ts @@ -0,0 +1,21 @@ +/// + +// @Filename: /defA.ts +////declare module "a" { +//// export type [|{| "isWriteAccess": true, "isDefinition": true |}T|] = number; +////} + +// @Filename: /defB.ts +////declare module "b" { +//// export import a = require("a"); +//// export const x: a.[|T|]; +////} + +// @Filename: /defC.ts +////declare module "c" { +//// import b = require("b"); +//// const x: b.a.[|T|]; +////} + +verify.noErrors(); +verify.singleReferenceGroup("type T = number"); diff --git a/tests/cases/fourslash/renameAcrossMultipleProjects.ts b/tests/cases/fourslash/renameAcrossMultipleProjects.ts index 44b5c0baef4..2cc5824a843 100644 --- a/tests/cases/fourslash/renameAcrossMultipleProjects.ts +++ b/tests/cases/fourslash/renameAcrossMultipleProjects.ts @@ -1,7 +1,7 @@ /// //@Filename: a.ts -////var /*1*/[|x|]: number; +////var [|x|]: number; //@Filename: b.ts /////// @@ -11,7 +11,4 @@ /////// ////[|x|]++; -goTo.file("a.ts"); -goTo.marker("1"); - -verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/renameAliasExternalModule2.ts b/tests/cases/fourslash/renameAliasExternalModule2.ts index 35916295a8e..8416d12f4b2 100644 --- a/tests/cases/fourslash/renameAliasExternalModule2.ts +++ b/tests/cases/fourslash/renameAliasExternalModule2.ts @@ -5,7 +5,9 @@ ////export = [|SomeModule|]; // @Filename: b.ts -////import M = require("./a"); -////import C = M.SomeClass; +////import [|M|] = require("./a"); +////import C = [|M|].SomeClass; -verify.rangesAreRenameLocations(); +const [r0, r1, r2, r3] = test.ranges(); +verify.rangesAreRenameLocations([r0, r1]); +verify.rangesAreRenameLocations([r2, r3]); diff --git a/tests/cases/fourslash/renameCommentsAndStrings1.ts b/tests/cases/fourslash/renameCommentsAndStrings1.ts index b7a1f5d61ae..cd350e3046c 100644 --- a/tests/cases/fourslash/renameCommentsAndStrings1.ts +++ b/tests/cases/fourslash/renameCommentsAndStrings1.ts @@ -1,11 +1,10 @@ /// -/////// +/////// -////function /**/[|Bar|]() { +////function [|Bar|]() { //// // This is a reference to Bar in a comment. //// "this is a reference to Bar in a string" ////} -goTo.marker(); -verify.renameLocations(/*findInStrings:*/ false, /*findInComments:*/ false); \ No newline at end of file +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/renameCommentsAndStrings2.ts b/tests/cases/fourslash/renameCommentsAndStrings2.ts index 590f3a0833f..e31c3b76900 100644 --- a/tests/cases/fourslash/renameCommentsAndStrings2.ts +++ b/tests/cases/fourslash/renameCommentsAndStrings2.ts @@ -1,11 +1,11 @@ /// -/////// +/////// -////function /**/[|Bar|]() { +////function [|Bar|]() { //// // This is a reference to Bar in a comment. //// "this is a reference to [|Bar|] in a string" ////} -goTo.marker(); -verify.renameLocations(/*findInStrings:*/ true, /*findInComments:*/ false); \ No newline at end of file +const ranges = test.ranges(); +verify.renameLocations(ranges[0], { findInStrings: true, ranges }) diff --git a/tests/cases/fourslash/renameCommentsAndStrings3.ts b/tests/cases/fourslash/renameCommentsAndStrings3.ts index 5f1aa09a948..7d88ddf2438 100644 --- a/tests/cases/fourslash/renameCommentsAndStrings3.ts +++ b/tests/cases/fourslash/renameCommentsAndStrings3.ts @@ -1,11 +1,11 @@ /// -/////// +/////// -////function /**/[|Bar|]() { +////function [|Bar|]() { //// // This is a reference to [|Bar|] in a comment. //// "this is a reference to Bar in a string" ////} -goTo.marker(); -verify.renameLocations(/*findInStrings:*/ false, /*findInComments:*/ true); \ No newline at end of file +const ranges = test.ranges(); +verify.renameLocations(ranges[0], { findInComments: true, ranges }); diff --git a/tests/cases/fourslash/renameCommentsAndStrings4.ts b/tests/cases/fourslash/renameCommentsAndStrings4.ts index 4f8b7b98cd4..b3975209fc4 100644 --- a/tests/cases/fourslash/renameCommentsAndStrings4.ts +++ b/tests/cases/fourslash/renameCommentsAndStrings4.ts @@ -1,11 +1,11 @@ /// -/////// +/////// ////function /**/[|Bar|]() { //// // This is a reference to [|Bar|] in a comment. //// "this is a reference to [|Bar|] in a string" ////} -goTo.marker(); -verify.renameLocations(/*findInStrings:*/ true, /*findInComments:*/ true); \ No newline at end of file +const ranges = test.ranges(); +verify.renameLocations(ranges[0], { findInStrings: true, findInComments: true, ranges }); diff --git a/tests/cases/fourslash/renameCrossJsTs01.ts b/tests/cases/fourslash/renameCrossJsTs01.ts index 52cb4c587d1..025118ef7f7 100644 --- a/tests/cases/fourslash/renameCrossJsTs01.ts +++ b/tests/cases/fourslash/renameCrossJsTs01.ts @@ -6,7 +6,6 @@ // @Filename: b.ts ////import { [|area|] } from './a'; -////var t = /**/[|area|](10); +////var t = [|area|](10); -goTo.marker(); -verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file +verify.rangesAreRenameLocations() diff --git a/tests/cases/fourslash/renameCrossJsTs02.ts b/tests/cases/fourslash/renameCrossJsTs02.ts deleted file mode 100644 index 7ff1ae96ff3..00000000000 --- a/tests/cases/fourslash/renameCrossJsTs02.ts +++ /dev/null @@ -1,12 +0,0 @@ -/// - -// @allowJs: true -// @Filename: a.js -////exports./**/[|area|] = function (r) { return r * r; } - -// @Filename: b.ts -////import { [|area|] } from './a'; -////var t = [|area|](10); - -goTo.marker(); -verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file diff --git a/tests/cases/fourslash/renameDefaultImport.ts b/tests/cases/fourslash/renameDefaultImport.ts index bcac46d7a63..086a05f6b99 100644 --- a/tests/cases/fourslash/renameDefaultImport.ts +++ b/tests/cases/fourslash/renameDefaultImport.ts @@ -16,14 +16,15 @@ verify.occurrencesAtPositionCount(1); const ranges = test.ranges(); const [C, B0, B1] = ranges; -verify.referenceGroups([C, B0], [{ definition: "class B", ranges }]); -verify.referenceGroups(B1, [{ definition: "constructor B(): B", ranges }]); -goTo.rangeStart(C); -verify.renameLocations(false, false, [C, B0, B1]); +const classes = { definition: "class B", ranges: [C] }; +const imports = { definition: "import B", ranges: [B0, B1] }; +verify.referenceGroups(C, [classes, imports]); +verify.referenceGroups(B0, [imports, classes]); +verify.referenceGroups(B1, [ + { definition: "(alias) new B(): B\nimport B", ranges: [B0, B1] }, + classes +]); -const rangesInB = [B0, B1]; -for (const r of rangesInB) { - goTo.rangeStart(r); - verify.renameLocations(false, false, rangesInB); -} +verify.renameLocations(C, ranges); +verify.rangesAreRenameLocations([B0, B1]); diff --git a/tests/cases/fourslash/renameDefaultImportDifferentName.ts b/tests/cases/fourslash/renameDefaultImportDifferentName.ts index 590c81c650c..ac44c26c443 100644 --- a/tests/cases/fourslash/renameDefaultImportDifferentName.ts +++ b/tests/cases/fourslash/renameDefaultImportDifferentName.ts @@ -16,14 +16,12 @@ verify.occurrencesAtPositionCount(1); const ranges = test.ranges(); const [C, B0, B1] = ranges; -verify.referenceGroups([C, B0], [{ definition: "class C", ranges }]); -verify.referenceGroups(B1, [{ definition: "constructor C(): B", ranges }]); +const bRanges = [B0, B1]; +const classes = { definition: "class C", ranges: [C] }; +const imports = { definition: "import B", ranges: [B0, B1] }; +verify.referenceGroups(C, [classes, imports]); +verify.referenceGroups(B0, [imports]); +verify.referenceGroups(B1, [{ definition: "(alias) new B(): B\nimport B", ranges: bRanges }]); -goTo.rangeStart(C); -verify.renameLocations(false, false, [C, B0, B1]); - -const rangesInB = [B0, B1]; -for (const r of rangesInB) { - goTo.rangeStart(r); - verify.renameLocations(false, false, rangesInB); -} +verify.rangesAreRenameLocations([C]); +verify.rangesAreRenameLocations(bRanges); diff --git a/tests/cases/fourslash/renameDestructuringAssignmentInFor.ts b/tests/cases/fourslash/renameDestructuringAssignmentInFor.ts index 6be57b81fa2..0ef6f672e00 100644 --- a/tests/cases/fourslash/renameDestructuringAssignmentInFor.ts +++ b/tests/cases/fourslash/renameDestructuringAssignmentInFor.ts @@ -1,20 +1,18 @@ /// -////interface I { -//// /*1*/[|property1|]: number; -//// property2: string; -////} -////var elems: I[]; -//// -////var p2: number, property1: number; -////for ({ [|property1|] } = elems[0]; p2 < 100; p2++) { -//// p2 = property1++; +////interface I { +//// [|property1|]: number; +//// property2: string; ////} -////for ({ /*2*/[|property1|]: p2 } = elems[0]; p2 < 100; p2++) { +////var elems: I[]; +//// +////var p2: number, property1: number; +////for ({ [|property1|] } = elems[0]; p2 < 100; p2++) { +//// p2 = property1++; +////} +////for ({ [|property1|]: p2 } = elems[0]; p2 < 100; p2++) { ////} -goTo.marker("1"); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); - -goTo.marker("2"); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); +const ranges = test.ranges(); +const [r0, , r2] = ranges; +verify.renameLocations([r0, r2], ranges); diff --git a/tests/cases/fourslash/renameDestructuringAssignmentInForOf.ts b/tests/cases/fourslash/renameDestructuringAssignmentInForOf.ts index d965875d259..b452ca7c9a7 100644 --- a/tests/cases/fourslash/renameDestructuringAssignmentInForOf.ts +++ b/tests/cases/fourslash/renameDestructuringAssignmentInForOf.ts @@ -1,7 +1,7 @@ -/// - +/// + ////interface I { -//// /*1*/[|property1|]: number; +//// [|property1|]: number; //// property2: string; ////} ////var elems: I[]; @@ -9,12 +9,10 @@ ////var property1: number, p2: number; ////for ({ [|property1|] } of elems) { //// property1++; -////} -////for ({ /*2*/[|property1|]: p2 } of elems) { -////} - -goTo.marker("1"); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); - -goTo.marker("2"); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file +////} +////for ({ [|property1|]: p2 } of elems) { +////} + +const ranges = test.ranges(); +const [r0, , r2] = ranges; +verify.renameLocations([r0, r2], ranges); diff --git a/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral.ts b/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral.ts index 9d5d2a041e5..57191e6d6ab 100644 --- a/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral.ts +++ b/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral.ts @@ -1,15 +1,13 @@ /// -////interface I { -//// /*1*/[|property1|]: number; -//// property2: string; -////} -////var elems: I[], p1: number, property1: number; -////[{ /*2*/[|property1|]: p1 }] = elems; -////[{ [|property1|] }] = elems; +////interface I { +//// [|property1|]: number; +//// property2: string; +////} +////var elems: I[], p1: number, property1: number; +////[{ [|property1|]: p1 }] = elems; +////[{ [|property1|] }] = elems; -goTo.marker("1"); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); - -goTo.marker("2"); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); +const ranges = test.ranges(); +const [r0, r1] = ranges; +verify.renameLocations([r0, r1], ranges); diff --git a/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor.ts b/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor.ts index e603c82dbd7..fe8961aa18c 100644 --- a/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor.ts +++ b/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor.ts @@ -1,22 +1,20 @@ -/// - +/// + ////interface MultiRobot { //// name: string; //// skills: { -//// /*1*/[|primary|]: string; +//// [|primary|]: string; //// secondary: string; //// }; ////} ////let multiRobot: MultiRobot; -////for ({ skills: { /*2*/[|primary|]: primaryA, secondary: secondaryA } } = multiRobot, i = 0; i < 1; i++) { +////for ({ skills: { [|primary|]: primaryA, secondary: secondaryA } } = multiRobot, i = 0; i < 1; i++) { //// console.log(primaryA); ////} ////for ({ skills: { [|primary|], secondary } } = multiRobot, i = 0; i < 1; i++) { //// console.log(primary); ////} - -goTo.marker("1"); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); - -goTo.marker("2"); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); + +const ranges = test.ranges(); +const [r0, r1] = ranges; +verify.renameLocations([r0, r1], ranges); diff --git a/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf.ts b/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf.ts index bef88d201d4..7d057600748 100644 --- a/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf.ts +++ b/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf.ts @@ -1,22 +1,20 @@ -/// - +/// + ////interface MultiRobot { //// name: string; //// skills: { -//// /*1*/[|primary|]: string; +//// [|primary|]: string; //// secondary: string; //// }; ////} ////let multiRobots: MultiRobot[]; -////for ({ skills: { /*2*/[|primary|]: primaryA, secondary: secondaryA } } of multiRobots) { +////for ({ skills: { [|primary|]: primaryA, secondary: secondaryA } } of multiRobots) { //// console.log(primaryA); ////} ////for ({ skills: { [|primary|], secondary } } of multiRobots) { //// console.log(primary); ////} - -goTo.marker("1"); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); - -goTo.marker("2"); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); + +const ranges = test.ranges(); +const [r0, r1] = ranges; +verify.renameLocations([r0, r1], ranges); diff --git a/tests/cases/fourslash/renameForDefaultExport01.ts b/tests/cases/fourslash/renameForDefaultExport01.ts index 96f0d6e54e8..1256a9698fa 100644 --- a/tests/cases/fourslash/renameForDefaultExport01.ts +++ b/tests/cases/fourslash/renameForDefaultExport01.ts @@ -1,13 +1,14 @@ /// -////export default class /*1*/[|DefaultExportedClass|] { +////export default class [|DefaultExportedClass|] { ////} /////* -//// * Commenting [|DefaultExportedClass|] +//// * Commenting [|{| "inComment": true |}DefaultExportedClass|] //// */ //// -////var x: /*2*/[|DefaultExportedClass|]; +////var x: [|DefaultExportedClass|]; //// -////var y = new /*3*/[|DefaultExportedClass|]; +////var y = new [|DefaultExportedClass|]; -goTo.eachMarker(() => verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true)); \ No newline at end of file +const ranges = test.ranges(); +verify.renameLocations(ranges.filter(r => !(r.marker && r.marker.data.inComment)), { findInComments: true, ranges }); diff --git a/tests/cases/fourslash/renameForDefaultExport02.ts b/tests/cases/fourslash/renameForDefaultExport02.ts index 471b10e32b2..a6f6116ec1a 100644 --- a/tests/cases/fourslash/renameForDefaultExport02.ts +++ b/tests/cases/fourslash/renameForDefaultExport02.ts @@ -4,11 +4,12 @@ //// return /*2*/[|DefaultExportedFunction|] ////} /////** -//// * Commenting [|DefaultExportedFunction|] +//// * Commenting [|{| "inComment": true |}DefaultExportedFunction|] //// */ //// ////var x: typeof /*3*/[|DefaultExportedFunction|]; //// ////var y = /*4*/[|DefaultExportedFunction|](); -goTo.eachMarker(() => verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true)); \ No newline at end of file +const ranges = test.ranges(); +verify.renameLocations(ranges.filter(r => !(r.marker && r.marker.data.inComment)), { findInComments: true, ranges }); diff --git a/tests/cases/fourslash/renameForDefaultExport03.ts b/tests/cases/fourslash/renameForDefaultExport03.ts index 1da6ff20b0b..edc22bb0db0 100644 --- a/tests/cases/fourslash/renameForDefaultExport03.ts +++ b/tests/cases/fourslash/renameForDefaultExport03.ts @@ -11,10 +11,11 @@ ////var y = /*4*/[|f|](); //// /////** -//// * Commenting [|f|] +//// * Commenting [|{| "inComment": true |}f|] //// */ ////namespace /*5*/[|f|] { //// var local = 100; ////} -goTo.eachMarker(() => verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true)); \ No newline at end of file +const ranges = test.ranges(); +verify.renameLocations(ranges.filter(r => !(r.marker && r.marker.data.inComment)), { findInComments: true, ranges }); diff --git a/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts b/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts index 656a48f24dd..30feb0760e9 100644 --- a/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts +++ b/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts @@ -7,4 +7,11 @@ ////import { [|{| "isWriteAccess": true, "isDefinition": true |}a|] } from './a'; ////export { [|{| "isWriteAccess": true, "isDefinition": true |}a|] }; -verify.singleReferenceGroup("var a: any"); +const ranges = test.ranges(); +const [r0, r1, r2] = ranges; +const vars = { definition: "var a: any", ranges: [r0] }; +const imports = { definition: "import a", ranges: [r1, r2] }; +verify.referenceGroups(r0, [vars, imports]); +verify.referenceGroups(r1, [imports, vars]); +verify.referenceGroups(r2, [imports, vars]); +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/renameImportOfExportEquals.ts b/tests/cases/fourslash/renameImportOfExportEquals.ts index 192acefd6fd..12cd86df647 100644 --- a/tests/cases/fourslash/renameImportOfExportEquals.ts +++ b/tests/cases/fourslash/renameImportOfExportEquals.ts @@ -1,14 +1,35 @@ /// -////declare namespace N { -//// export var x: number; +////declare namespace [|{| "isWriteAccess": true, "isDefinition": true |}N|] { +//// export var [|{| "isWriteAccess": true, "isDefinition": true |}x|]: number; ////} ////declare module "mod" { -//// export = N; +//// export = [|N|]; ////} -////declare module "test" { -//// import * as [|N|] from "mod"; -//// export { [|N|] }; // Renaming N here would rename +////declare module "a" { +//// import * as [|{| "isWriteAccess": true, "isDefinition": true |}N|] from "mod"; +//// export { [|{| "isWriteAccess": true, "isDefinition": true |}N|] }; // Renaming N here would rename +////} +////declare module "b" { +//// import { [|{| "isWriteAccess": true, "isDefinition": true |}N|] } from "a"; +//// export const y: typeof [|N|].[|x|]; ////} -verify.rangesAreRenameLocations(); +const [N0, x0, N1, a0, a1, b0, b1, x1] = test.ranges(); +const nRanges = [N0, N1]; +const aRanges = [a0, a1]; +const bRanges = [b0, b1]; +const xRanges = [x0, x1]; + +const nGroup = { definition: "namespace N", ranges: nRanges }; +const aGroup = { definition: "import N", ranges: aRanges }; +const bGroup = { definition: "import N", ranges: [b0, b1] }; + +verify.referenceGroups(nRanges, [nGroup, aGroup, bGroup]); +verify.referenceGroups([a0, a1], [aGroup, nGroup, bGroup]); +verify.referenceGroups(bRanges, [bGroup, aGroup, nGroup]); +verify.singleReferenceGroup("var N.x: number", xRanges); + +verify.renameLocations(nRanges, nRanges.concat(aRanges, bRanges)); +verify.rangesAreRenameLocations(aRanges.concat(bRanges)); +verify.rangesAreRenameLocations(xRanges); diff --git a/tests/cases/fourslash/renameImportOfExportEquals2.ts b/tests/cases/fourslash/renameImportOfExportEquals2.ts new file mode 100644 index 00000000000..f57a10c5777 --- /dev/null +++ b/tests/cases/fourslash/renameImportOfExportEquals2.ts @@ -0,0 +1,36 @@ +/// + +////declare namespace [|{| "isWriteAccess": true, "isDefinition": true |}N|] { +//// export var x: number; +////} +////declare module "mod" { +//// export = [|N|]; +////} +////declare module "a" { +//// import * as [|{| "isWriteAccess": true, "isDefinition": true |}O|] from "mod"; +//// export { [|{| "isWriteAccess": true, "isDefinition": true |}O|] as [|{| "isWriteAccess": true, "isDefinition": true |}P|] }; // Renaming N here would rename +////} +////declare module "b" { +//// import { [|{| "isWriteAccess": true, "isDefinition": true |}P|] as [|{| "isWriteAccess": true, "isDefinition": true |}Q|] } from "a"; +//// export const y: typeof [|Q|].x; +////} + +verify.noErrors(); + +const [N0, N1, O0, O1, P0, P1, Q0, Q1] = test.ranges(); +const nRanges = [N0, N1]; +const oRanges = [O0, O1]; +const pRanges = [P0, P1]; +const qRanges = [Q0, Q1]; + +const ns = { definition: "namespace N", ranges: nRanges }; +const os = { definition: "import O", ranges: oRanges }; +const ps = { definition: "import P", ranges: pRanges }; +const qs = { definition: "import Q", ranges: qRanges }; + +verify.referenceGroups(nRanges, [ns, os, ps, qs]); +verify.referenceGroups(oRanges, [os, ps, qs]); +verify.referenceGroups(pRanges, [ps, qs]); +verify.referenceGroups(qRanges, [qs]); + +verify.rangesWithSameTextAreRenameLocations(); diff --git a/tests/cases/fourslash/renameImportOfReExport.ts b/tests/cases/fourslash/renameImportOfReExport.ts new file mode 100644 index 00000000000..3f8250b4d77 --- /dev/null +++ b/tests/cases/fourslash/renameImportOfReExport.ts @@ -0,0 +1,27 @@ +/// +// @noLib: true + +////declare module "a" { +//// export class [|{| "isWriteAccess": true, "isDefinition": true |}C|] {} +////} +////declare module "b" { +//// export { [|{| "isWriteAccess": true, "isDefinition": true |}C|] } from "a"; +////} +////declare module "c" { +//// import { [|{| "isWriteAccess": true, "isDefinition": true |}C|] } from "b"; +//// export function f(c: [|C|]): void; +////} + +verify.noErrors(); + +verify.rangesAreRenameLocations(); + +const ranges = test.ranges(); +const [r0, r1, r2, r3] = ranges; +const importRanges = [r2, r3]; +const classes = { definition: "class C", ranges: [r0] }; +const bs = { definition: "import C", ranges: [r1] }; +const imports = { definition: "import C", ranges: importRanges }; +verify.referenceGroups(r0, [classes, bs, imports]); +verify.referenceGroups(r1, [bs, imports, classes]); +verify.referenceGroups(importRanges, [imports, bs, classes]); diff --git a/tests/cases/fourslash/renameImportOfReExport2.ts b/tests/cases/fourslash/renameImportOfReExport2.ts new file mode 100644 index 00000000000..56cc3966112 --- /dev/null +++ b/tests/cases/fourslash/renameImportOfReExport2.ts @@ -0,0 +1,28 @@ +/// + +////declare module "a" { +//// export class [|{| "isWriteAccess": true, "isDefinition": true |}C|] {} +////} +////declare module "b" { +//// export { [|{| "isWriteAccess": true, "isDefinition": true |}C|] as [|{| "isWriteAccess": true, "isDefinition": true |}D|] } from "a"; +////} +////declare module "c" { +//// import { [|{| "isWriteAccess": true, "isDefinition": true |}D|] } from "b"; +//// export function f(c: [|D|]): void; +////} + +verify.noErrors(); + +const ranges = test.rangesByText(); +const cRanges = ranges.get("C"); +const [d0, d1, d2] = ranges.get("D"); + +const classes = { definition: "class C", ranges: cRanges }; +const bImports = { definition: "import D", ranges: [d0] }; +const cImports = { definition: "import D", ranges: [d1, d2] }; +verify.referenceGroups(cRanges, [classes, bImports, cImports]); + +verify.referenceGroups(d0, [bImports, cImports]); +verify.referenceGroups([d1, d2], [cImports, bImports]); + +verify.rangesWithSameTextAreRenameLocations(); diff --git a/tests/cases/fourslash/renameJsExports01.ts b/tests/cases/fourslash/renameJsExports01.ts index 923d30eedf9..b731ece63f3 100644 --- a/tests/cases/fourslash/renameJsExports01.ts +++ b/tests/cases/fourslash/renameJsExports01.ts @@ -8,5 +8,5 @@ ////var mod = require('./a'); ////var t = mod./**/[|area|](10); -goTo.marker(); -verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file +verify.singleReferenceGroup("(property) area: (r: any) => number"); +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/renameJsExports02.ts b/tests/cases/fourslash/renameJsExports02.ts deleted file mode 100644 index 86b0471dc1f..00000000000 --- a/tests/cases/fourslash/renameJsExports02.ts +++ /dev/null @@ -1,12 +0,0 @@ -/// - -// @allowJs: true -// @Filename: a.js -////exports./**/[|area|] = function (r) { return r * r; } - -// @Filename: b.js -////var mod = require('./a'); -////var t = mod.[|area|](10); - -goTo.marker(); -verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file diff --git a/tests/cases/fourslash/renameJsPrototypeProperty01.ts b/tests/cases/fourslash/renameJsPrototypeProperty01.ts index f756f57edbf..1700f15619d 100644 --- a/tests/cases/fourslash/renameJsPrototypeProperty01.ts +++ b/tests/cases/fourslash/renameJsPrototypeProperty01.ts @@ -6,7 +6,6 @@ ////} ////bar.prototype.[|x|] = 10; ////var t = new bar(); -////t./**/[|x|] = 11; +////t.[|x|] = 11; -goTo.marker(); -verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/renameJsPrototypeProperty02.ts b/tests/cases/fourslash/renameJsPrototypeProperty02.ts index 721dc312eb6..1700f15619d 100644 --- a/tests/cases/fourslash/renameJsPrototypeProperty02.ts +++ b/tests/cases/fourslash/renameJsPrototypeProperty02.ts @@ -4,9 +4,8 @@ // @Filename: a.js ////function bar() { ////} -////bar.prototype./**/[|x|] = 10; +////bar.prototype.[|x|] = 10; ////var t = new bar(); ////t.[|x|] = 11; -goTo.marker(); -verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/renameJsThisProperty01.ts b/tests/cases/fourslash/renameJsThisProperty01.ts index 91338e0431d..5680dbf08fd 100644 --- a/tests/cases/fourslash/renameJsThisProperty01.ts +++ b/tests/cases/fourslash/renameJsThisProperty01.ts @@ -6,7 +6,6 @@ //// this.[|x|] = 10; ////} ////var t = new bar(); -////t./**/[|x|] = 11; +////t.[|x|] = 11; -goTo.marker(); -verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/renameJsThisProperty02.ts b/tests/cases/fourslash/renameJsThisProperty02.ts deleted file mode 100644 index 8398507c9ca..00000000000 --- a/tests/cases/fourslash/renameJsThisProperty02.ts +++ /dev/null @@ -1,12 +0,0 @@ -/// - -// @allowJs: true -// @Filename: a.js -////function bar() { -//// this./**/[|x|] = 10; -////} -////var t = new bar(); -////t.[|x|] = 11; - -goTo.marker(); -verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); \ No newline at end of file diff --git a/tests/cases/fourslash/renameJsThisProperty03.ts b/tests/cases/fourslash/renameJsThisProperty03.ts index f2176538578..8633c61132c 100644 --- a/tests/cases/fourslash/renameJsThisProperty03.ts +++ b/tests/cases/fourslash/renameJsThisProperty03.ts @@ -4,11 +4,10 @@ // @Filename: a.js ////class C { //// constructor(y) { -//// this./**/[|x|] = y; +//// this.[|x|] = y; //// } ////} ////var t = new C(12); ////t.[|x|] = 11; -goTo.marker(); -verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/renameJsThisProperty04.ts b/tests/cases/fourslash/renameJsThisProperty04.ts deleted file mode 100644 index e307022c66f..00000000000 --- a/tests/cases/fourslash/renameJsThisProperty04.ts +++ /dev/null @@ -1,14 +0,0 @@ -/// - -// @allowJs: true -// @Filename: a.js -////class C { -//// constructor(y) { -//// this.[|x|] = y; -//// } -////} -////var t = new C(12); -////t./**/[|x|] = 11; - -goTo.marker(); -verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false); diff --git a/tests/cases/fourslash/renameModuleToVar.ts b/tests/cases/fourslash/renameModuleToVar.ts index fc31f4040e8..8f01f909c83 100644 --- a/tests/cases/fourslash/renameModuleToVar.ts +++ b/tests/cases/fourslash/renameModuleToVar.ts @@ -13,4 +13,4 @@ goTo.marker(); edit.backspace(6); edit.insert("var"); -verify.numberOfErrorsInCurrentFile(0); +verify.noErrors(); diff --git a/tests/cases/fourslash/renameObjectSpread.ts b/tests/cases/fourslash/renameObjectSpread.ts index f56c22dd42f..f3af6e0280f 100644 --- a/tests/cases/fourslash/renameObjectSpread.ts +++ b/tests/cases/fourslash/renameObjectSpread.ts @@ -6,15 +6,11 @@ ////let a2: A2; ////let a12 = { ...a1, ...a2 }; ////a12.[|a|]; -const ranges = test.ranges(); -verify.assertHasRanges(ranges); +const [r0, r1, r2] = test.ranges(); // A1 unions with A2, so rename A1.a and a12.a -goTo.rangeStart(ranges[0]); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[2]]); +verify.renameLocations(r0, [r0, r2]); // A1 unions with A2, so rename A2.a and a12.a -goTo.rangeStart(ranges[1]); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[1], ranges[2]]); +verify.renameLocations(r1, [r1, r2]); // a12.a unions A1.a and A2.a, so rename A1.a, A2.a and a12.a -goTo.rangeStart(ranges[2]); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[1], ranges[2]]); +verify.renameLocations(r2, [r0, r1, r2]); diff --git a/tests/cases/fourslash/renameObjectSpreadAssignment.ts b/tests/cases/fourslash/renameObjectSpreadAssignment.ts index 2ddebb6e18b..9d55e43afa5 100644 --- a/tests/cases/fourslash/renameObjectSpreadAssignment.ts +++ b/tests/cases/fourslash/renameObjectSpreadAssignment.ts @@ -6,17 +6,6 @@ ////let [|a2|]: A2; ////let a12 = { ...[|a1|], ...[|a2|] }; -const ranges = test.ranges(); -verify.assertHasRanges(ranges); - - -// rename a1 -goTo.rangeStart(ranges[0]); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[2]]); -goTo.rangeStart(ranges[2]); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[2]]); -// rename a2 -goTo.rangeStart(ranges[1]); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[1], ranges[3]]); -goTo.rangeStart(ranges[3]); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[1], ranges[3]]); +const [r0, r1, r2, r3] = test.ranges(); +verify.rangesAreRenameLocations([r0, r2]); +verify.rangesAreRenameLocations([r1, r3]); diff --git a/tests/cases/fourslash/renameStingPropertyNames.ts b/tests/cases/fourslash/renameStringPropertyNames.ts similarity index 100% rename from tests/cases/fourslash/renameStingPropertyNames.ts rename to tests/cases/fourslash/renameStringPropertyNames.ts diff --git a/tests/cases/fourslash/renameThis.ts b/tests/cases/fourslash/renameThis.ts index c4e5d932261..e626294bf46 100644 --- a/tests/cases/fourslash/renameThis.ts +++ b/tests/cases/fourslash/renameThis.ts @@ -6,17 +6,12 @@ ////this/**/; ////const _ = { [|this|]: 0 }.[|this|]; -let [r0, r1, r2, r3] = test.ranges() -for (let range of [r0, r1]) { - goTo.rangeStart(range); - verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [r0, r1]); -} +const [r0, r1, r2, r3] = test.ranges() +verify.rangesAreRenameLocations([r0, r1]); // Trying to rename a non-parameter 'this' should fail goTo.marker(); verify.renameInfoFailed("You cannot rename this element."); -for (let range of [r2, r3]) { - goTo.rangeStart(range); - verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [r2, r3]); -} +verify.rangesAreRenameLocations([r2, r3]); + diff --git a/tests/cases/fourslash/server/jsdocTypedefTagRename01.ts b/tests/cases/fourslash/server/jsdocTypedefTagRename01.ts index 776d0180b06..38a35b58cbf 100644 --- a/tests/cases/fourslash/server/jsdocTypedefTagRename01.ts +++ b/tests/cases/fourslash/server/jsdocTypedefTagRename01.ts @@ -4,17 +4,11 @@ // @Filename: jsDocTypedef_form1.js //// //// /** @typedef {(string | number)} */ -//// var /*1*/[|NumberLike|]; +//// var [|NumberLike|]; //// -//// /*2*/[|NumberLike|] = 10; +//// [|NumberLike|] = 10; //// -//// /** @type {/*3*/[|NumberLike|]} */ +//// /** @type {[|NumberLike|]} */ //// var numberLike; -goTo.file('jsDocTypedef_form1.js') -goTo.marker('1'); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); -goTo.marker('2'); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); -goTo.marker('3'); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); \ No newline at end of file +verify.rangesAreRenameLocations({ findInComments: true }); diff --git a/tests/cases/fourslash/server/jsdocTypedefTagRename02.ts b/tests/cases/fourslash/server/jsdocTypedefTagRename02.ts index 7f1d422d971..38da754247f 100644 --- a/tests/cases/fourslash/server/jsdocTypedefTagRename02.ts +++ b/tests/cases/fourslash/server/jsdocTypedefTagRename02.ts @@ -3,13 +3,9 @@ // @allowNonTsExtensions: true // @Filename: jsDocTypedef_form2.js //// -//// /** @typedef {(string | number)} /*1*/[|NumberLike|] */ +//// /** @typedef {(string | number)} [|NumberLike|] */ //// -//// /** @type {/*2*/[|NumberLike|]} */ +//// /** @type {[|NumberLike|]} */ //// var numberLike; -goTo.file('jsDocTypedef_form2.js') -goTo.marker('1'); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); -goTo.marker('2'); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); \ No newline at end of file +verify.rangesAreRenameLocations({ findInComments: true }); diff --git a/tests/cases/fourslash/server/jsdocTypedefTagRename03.ts b/tests/cases/fourslash/server/jsdocTypedefTagRename03.ts index c1b38945806..7b61682e594 100644 --- a/tests/cases/fourslash/server/jsdocTypedefTagRename03.ts +++ b/tests/cases/fourslash/server/jsdocTypedefTagRename03.ts @@ -3,7 +3,7 @@ // @allowNonTsExtensions: true // @Filename: jsDocTypedef_form3.js //// -//// /** +//// /** //// * @typedef /*1*/[|Person|] //// * @type {Object} //// * @property {number} age @@ -14,7 +14,4 @@ //// var person; goTo.file('jsDocTypedef_form3.js') -goTo.marker('1'); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); -goTo.marker('2'); -verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true); \ No newline at end of file +verify.rangesAreRenameLocations({ findInComments: true }); diff --git a/tests/cases/fourslash/server/rename01.ts b/tests/cases/fourslash/server/rename01.ts index 2da25f87ba7..74385c30da3 100644 --- a/tests/cases/fourslash/server/rename01.ts +++ b/tests/cases/fourslash/server/rename01.ts @@ -1,11 +1,11 @@ /// -/////// +/////// -////function /**/[|Bar|]() { +////function [|Bar|]() { //// // This is a reference to [|Bar|] in a comment. //// "this is a reference to [|Bar|] in a string" ////} -goTo.marker(); -verify.renameLocations(/*findInStrings:*/ true, /*findInComments:*/ true); \ No newline at end of file +const ranges = test.ranges(); +verify.renameLocations(ranges[0], { findInStrings: true, findInComments: true, ranges }); diff --git a/tests/cases/fourslash/server/renameInConfiguredProject.ts b/tests/cases/fourslash/server/renameInConfiguredProject.ts index ecff87493a8..a235f783f4c 100644 --- a/tests/cases/fourslash/server/renameInConfiguredProject.ts +++ b/tests/cases/fourslash/server/renameInConfiguredProject.ts @@ -4,10 +4,9 @@ ////var [|globalName|] = 0; // @Filename: referencesForGlobals_2.ts -////var y = /*1*/[|globalName|]; +////var y = [|globalName|]; // @Filename: tsconfig.json ////{ "files": ["referencesForGlobals_1.ts", "referencesForGlobals_2.ts"] } -goTo.marker("1"); -verify.renameLocations(/*findInStrings:*/ true, /*findInComments:*/ true); +verify.rangesAreRenameLocations({ findInStrings: true, findInComments: true }); diff --git a/tests/cases/fourslash/shims-pp/getRenameInfo.ts b/tests/cases/fourslash/shims-pp/getRenameInfo.ts index b7a1f5d61ae..aa04d69962a 100644 --- a/tests/cases/fourslash/shims-pp/getRenameInfo.ts +++ b/tests/cases/fourslash/shims-pp/getRenameInfo.ts @@ -1,11 +1,10 @@ -/// +/// -/////// +/////// -////function /**/[|Bar|]() { +////function [|Bar|]() { //// // This is a reference to Bar in a comment. //// "this is a reference to Bar in a string" ////} -goTo.marker(); -verify.renameLocations(/*findInStrings:*/ false, /*findInComments:*/ false); \ No newline at end of file +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/shims/getRenameInfo.ts b/tests/cases/fourslash/shims/getRenameInfo.ts index b7a1f5d61ae..aa04d69962a 100644 --- a/tests/cases/fourslash/shims/getRenameInfo.ts +++ b/tests/cases/fourslash/shims/getRenameInfo.ts @@ -1,11 +1,10 @@ -/// +/// -/////// +/////// -////function /**/[|Bar|]() { +////function [|Bar|]() { //// // This is a reference to Bar in a comment. //// "this is a reference to Bar in a string" ////} -goTo.marker(); -verify.renameLocations(/*findInStrings:*/ false, /*findInComments:*/ false); \ No newline at end of file +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/superInDerivedTypeOfGenericWithStatics.ts b/tests/cases/fourslash/superInDerivedTypeOfGenericWithStatics.ts index ddada820ee0..be381c764f3 100644 --- a/tests/cases/fourslash/superInDerivedTypeOfGenericWithStatics.ts +++ b/tests/cases/fourslash/superInDerivedTypeOfGenericWithStatics.ts @@ -2,7 +2,7 @@ ////module M { //// export class C { -//// static foo(): C { +//// static foo(): C { //// return null; //// } //// } @@ -15,4 +15,4 @@ goTo.marker(); edit.insert('super();'); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); \ No newline at end of file diff --git a/tests/cases/fourslash/transitiveExportImports.ts b/tests/cases/fourslash/transitiveExportImports.ts index 6ac905f017d..093121c1d9e 100644 --- a/tests/cases/fourslash/transitiveExportImports.ts +++ b/tests/cases/fourslash/transitiveExportImports.ts @@ -1,17 +1,36 @@ /// // @Filename: a.ts -////class A { +////class [|{| "isWriteAccess": true, "isDefinition": true |}A|] { ////} -////export = A; +////export = [|A|]; // @Filename: b.ts -////export import a = require('./a'); +////export import [|{| "isWriteAccess": true, "isDefinition": true |}b|] = require('./a'); // @Filename: c.ts -////import b = require('./b'); -////var a = new b./**/a(); +////import [|{| "isWriteAccess": true, "isDefinition": true |}b|] = require('./b'); +////var a = new [|b|]./**/[|b|](); goTo.marker(); verify.quickInfoExists(); -verify.numberOfErrorsInCurrentFile(0); \ No newline at end of file +verify.noErrors(); + +const [a0, a1, b0, c0, c1, c2] = test.ranges(); +const aRanges = [a0, a1]; +const bRanges = [b0, c2]; +const cRanges = [c0, c1]; + +const bGroup = { definition: "import b = require('./a')", ranges: bRanges } + +verify.referenceGroups(aRanges, [ + { definition: "class A", ranges: aRanges }, + bGroup +]); +verify.referenceGroups(b0, [bGroup]); +verify.referenceGroups(c2, [{ ...bGroup, definition: "(alias) new b.b(): b.b\nimport b.b = require('./a')"}]); +verify.singleReferenceGroup("import b = require('./b')", cRanges); + +verify.rangesAreRenameLocations(aRanges); +verify.rangesAreRenameLocations(bRanges); +verify.rangesAreRenameLocations(cRanges); diff --git a/tests/cases/fourslash/transitiveExportImports2.ts b/tests/cases/fourslash/transitiveExportImports2.ts new file mode 100644 index 00000000000..397bbf44a37 --- /dev/null +++ b/tests/cases/fourslash/transitiveExportImports2.ts @@ -0,0 +1,30 @@ +/// + +// @Filename: a.ts +////namespace [|{| "isWriteAccess": true, "isDefinition": true |}A|] { +//// export const x = 0; +////} + +// @Filename: b.ts +////export import [|{| "isWriteAccess": true, "isDefinition": true |}B|] = [|A|]; +////[|B|].x; + +// @Filename: c.ts +////import { [|{| "isWriteAccess": true, "isDefinition": true |}B|] } from "./b"; + +verify.noErrors(); + +const [A0, B0, A1, B1, B2] = test.ranges(); +const aRanges = [A0, A1]; +const bRanges = [B0, B1]; +const cRanges = [B2]; + +const aGroup = { definition: "namespace A", ranges: aRanges }; +const bGroup = { definition: "import B = A", ranges: bRanges }; +const cGroup = { definition: "import B", ranges: cRanges }; + +verify.referenceGroups(aRanges, [aGroup, bGroup, cGroup]); +verify.referenceGroups(bRanges, [bGroup, cGroup]); +verify.referenceGroups(cRanges, [cGroup, bGroup]); + +verify.rangesWithSameTextAreRenameLocations(); diff --git a/tests/cases/fourslash/transitiveExportImports3.ts b/tests/cases/fourslash/transitiveExportImports3.ts new file mode 100644 index 00000000000..6b3bb10572d --- /dev/null +++ b/tests/cases/fourslash/transitiveExportImports3.ts @@ -0,0 +1,25 @@ +/// + +// @Filename: a.ts +////export function [|{| "isWriteAccess": true, "isDefinition": true |}f|]() {} + +// @Filename: b.ts +////export { [|{| "isWriteAccess": true, "isDefinition": true |}f|] as [|{| "isWriteAccess": true, "isDefinition": true |}g|] } from "./a"; +////import { [|{| "isWriteAccess": true, "isDefinition": true |}f|] } from "./a"; +////import { [|{| "isWriteAccess": true, "isDefinition": true |}g|] } from "./b"; + +verify.noErrors(); + +const [f0, f1, g0, f2, g1] = test.ranges(); + +const af = { definition: "function f(): void", ranges: [f0, f1] }; +const g0Group = { definition: "import g", ranges: [g0] }; +const g1Group = { definition: "import g", ranges: [g1] }; +const bf = { definition: "import f", ranges: [f2] }; + +verify.referenceGroups([f0, f1], [af, g0Group, g1Group, bf]); +verify.referenceGroups(g0, [g0Group, g1Group]); +verify.referenceGroups(g1, [g1Group, g0Group]); +verify.referenceGroups(f2, [bf, af, g0Group, g1Group]); + +verify.rangesWithSameTextAreRenameLocations(); diff --git a/tests/cases/fourslash/tsxRename1.ts b/tests/cases/fourslash/tsxRename1.ts index 3fb973ec996..4323e99df59 100644 --- a/tests/cases/fourslash/tsxRename1.ts +++ b/tests/cases/fourslash/tsxRename1.ts @@ -11,7 +11,6 @@ //// span: { n: string; }; //// } //// } -//// var x = <[|di/*ds*/v|] />; +//// var x = <[|div|] />; -goTo.marker('ds'); -verify.renameLocations(false, false); +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/tsxRename2.ts b/tests/cases/fourslash/tsxRename2.ts index d0f5737214b..e5e0688150c 100644 --- a/tests/cases/fourslash/tsxRename2.ts +++ b/tests/cases/fourslash/tsxRename2.ts @@ -11,7 +11,6 @@ //// span: { n: string; }; //// } //// } -//// var x =
; +//// var x =
; -goTo.marker(); -verify.renameLocations(false, false); +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/tsxRename3.ts b/tests/cases/fourslash/tsxRename3.ts index 1ab9c8a5915..b997ea2fdca 100644 --- a/tests/cases/fourslash/tsxRename3.ts +++ b/tests/cases/fourslash/tsxRename3.ts @@ -12,9 +12,8 @@ //// [|name|]?: string; //// size?: number; //// } -//// -//// -//// var x = ; +//// +//// +//// var x = ; -goTo.marker(); -verify.renameLocations(false, false); +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/tsxRename4.ts b/tests/cases/fourslash/tsxRename4.ts index baaa31bdc4d..a7e57cca258 100644 --- a/tests/cases/fourslash/tsxRename4.ts +++ b/tests/cases/fourslash/tsxRename4.ts @@ -12,9 +12,8 @@ //// name?: string; //// size?: number; //// } -//// -//// -//// var x = <[|MyC/**/lass|] name='hello'>; +//// +//// +//// var x = <[|MyClass|] name='hello'>; -goTo.marker(); -verify.renameLocations(false, false); +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/tsxRename5.ts b/tests/cases/fourslash/tsxRename5.ts index cc18d6287c3..a4c70b4b1c3 100644 --- a/tests/cases/fourslash/tsxRename5.ts +++ b/tests/cases/fourslash/tsxRename5.ts @@ -12,9 +12,8 @@ //// name?: string; //// size?: number; //// } -//// +//// //// var [|nn|]: string; -//// var x = ; +//// var x = ; -goTo.marker(); -verify.renameLocations(false, false); +verify.rangesAreRenameLocations(); From d99a46e8ce31d511deb4590c3822948544583396 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Mon, 13 Feb 2017 09:01:30 -0800 Subject: [PATCH 04/35] Better handle additional re-export cases --- src/services/findAllReferences.ts | 73 +++++++++++-------- src/services/importTracker.ts | 1 + tests/cases/fourslash/findAllRefsIII.ts | 16 ---- ...findAllRefsReExportRightNameWrongSymbol.ts | 37 ++++++++++ .../findAllRefsRenameImportWithSameName.ts | 20 +++++ 5 files changed, 101 insertions(+), 46 deletions(-) delete mode 100644 tests/cases/fourslash/findAllRefsIII.ts create mode 100644 tests/cases/fourslash/findAllRefsReExportRightNameWrongSymbol.ts create mode 100644 tests/cases/fourslash/findAllRefsRenameImportWithSameName.ts diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index c48aa6d2316..9da43c1771f 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -235,16 +235,16 @@ namespace ts.FindAllReferences { markSeenContainingTypeReference(containingTypeReference: Node): boolean; /** - * It's possible that we will encounter either side of `export { foo as bar } from "x";` more than once. + * It's possible that we will encounter the right side of `export { foo as bar } from "x";` more than once. * For example: - * export { foo as bar } from "a"; - * import { foo } from "a"; + * // b.ts + * export { foo as bar } from "./a"; + * import { bar } from "./b"; * * Normally at `foo as bar` we directly add `foo` and do not locally search for it (since it doesn't declare a local). * But another reference to it may appear in the same source file. * See `tests/cases/fourslash/transitiveExportImports3.ts`. */ - markSeenReExportLHS(lhs: Identifier): boolean; markSeenReExportRHS(rhs: Identifier): boolean; } @@ -259,7 +259,7 @@ namespace ts.FindAllReferences { return { ...options, sourceFiles, isForConstructor, checker, cancellationToken, searchMeaning, inheritsFromCache, getImportSearches, createSearch, referenceAdder, addStringOrCommentReference, - markSearchedSymbol, markSeenContainingTypeReference: nodeSeenTracker(), markSeenReExportLHS: nodeSeenTracker(), markSeenReExportRHS: nodeSeenTracker(), + markSearchedSymbol, markSeenContainingTypeReference: nodeSeenTracker(), markSeenReExportRHS: nodeSeenTracker(), }; function getImportSearches(exportSymbol: Symbol, exportInfo: ExportInfo): ImportsResult { @@ -312,9 +312,7 @@ namespace ts.FindAllReferences { if (singleReferences.length) { const addRef = state.referenceAdder(exportSymbol, exportLocation); for (const singleRef of singleReferences) { - if (state.markSeenReExportLHS(singleRef)) { - addRef(singleRef); - } + addRef(singleRef); } } @@ -648,9 +646,15 @@ namespace ts.FindAllReferences { return; } - if (isExportSpecifier(referenceLocation.parent)) { + const { parent } = referenceLocation; + if (isImportSpecifier(parent) && parent.propertyName === referenceLocation) { + // This is added through `singleReferences` in ImportsResult. If we happen to see it again, don't add it again. + return; + } + + if (isExportSpecifier(parent)) { Debug.assert(referenceLocation.kind === SyntaxKind.Identifier); - getReferencesAtExportSpecifier(referenceLocation as Identifier, referenceSymbol, referenceLocation.parent, search, state); + getReferencesAtExportSpecifier(referenceLocation as Identifier, referenceSymbol, parent, search, state); return; } @@ -672,39 +676,48 @@ namespace ts.FindAllReferences { function getReferencesAtExportSpecifier(referenceLocation: Identifier, referenceSymbol: Symbol, exportSpecifier: ExportSpecifier, search: Search, state: State): void { const { parent, propertyName, name } = exportSpecifier; - searchForExport(getLocalSymbolForExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, state.checker)); - const exportDeclaration = parent.parent; - if (search.comingFrom !== ImportExport.Export && exportDeclaration.moduleSpecifier && !propertyName) { - searchForImportedSymbol(state.checker.getExportSpecifierLocalTargetSymbol(exportSpecifier), state); + const localSymbol = getLocalSymbolForExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, state.checker); + if (!search.includes(localSymbol)) { + return; } - function searchForExport(localSymbol: Symbol): void { - if (!search.includes(localSymbol)) { - return; + if (!propertyName) { + addRef() + } + else if (referenceLocation === propertyName) { + // For `export { foo as bar } from "baz"`, "`foo`" will be added from the singleReferences for import searches of the original export. + // For `export { foo as bar };`, where `foo` is a local, so add it now. + if (!exportDeclaration.moduleSpecifier) { + addRef(); } - if (!propertyName || (propertyName === referenceLocation ? state.markSeenReExportLHS : state.markSeenReExportRHS)(referenceLocation)) { - addReference(referenceLocation, localSymbol, search.location, state); + if (!state.isForRename && state.markSeenReExportRHS(name)) { + addReference(name, referenceSymbol, name, state); } - - const renameExportRHS = propertyName === referenceLocation ? name : undefined; - if (renameExportRHS) { - // For `export { foo as bar }`, rename `foo`, but not `bar`. - if (state.isForRename) { - return; - } - - if (state.markSeenReExportRHS(renameExportRHS)) { - addReference(renameExportRHS, referenceSymbol, renameExportRHS, state); - } + } + else { + if (state.markSeenReExportRHS(referenceLocation)) { + addRef(); } + } + // For `export { foo as bar }`, rename `foo`, but not `bar`. + if (!(referenceLocation === propertyName && state.isForRename)) { const exportKind = (referenceLocation as Identifier).originalKeywordKind === ts.SyntaxKind.DefaultKeyword ? ExportKind.Default : ExportKind.Named; const exportInfo = getExportInfo(referenceSymbol, exportKind, state.checker); Debug.assert(!!exportInfo); searchForImportsOfExport(referenceLocation, referenceSymbol, exportInfo, state); } + + // At `export { x } from "foo"`, also search for the imported symbol `"foo".x`. + if (search.comingFrom !== ImportExport.Export && exportDeclaration.moduleSpecifier && !propertyName) { + searchForImportedSymbol(state.checker.getExportSpecifierLocalTargetSymbol(exportSpecifier), state); + } + + function addRef() { + addReference(referenceLocation, localSymbol, search.location, state); + } } function getLocalSymbolForExportSpecifier(referenceLocation: Identifier, referenceSymbol: Symbol, exportSpecifier: ExportSpecifier, checker: TypeChecker): Symbol { diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts index 3f4e896faf2..154b046dc40 100644 --- a/src/services/importTracker.ts +++ b/src/services/importTracker.ts @@ -367,6 +367,7 @@ namespace ts.FindAllReferences { * Given a local reference, we might notice that it's an import/export and recursively search for references of that. * If at an import, look locally for the symbol it imports. * If an an export, look for all imports of it. + * This doesn't handle export specifiers; that is done in `getReferencesAtExportSpecifier`. * @param comingFromExport If we are doing a search for all exports, don't bother looking backwards for the imported symbol, since that's the reason we're here. */ export function getImportOrExportSymbol(node: Node, symbol: Symbol, checker: TypeChecker, comingFromExport: boolean): ImportedSymbol | ExportedSymbol | undefined { diff --git a/tests/cases/fourslash/findAllRefsIII.ts b/tests/cases/fourslash/findAllRefsIII.ts deleted file mode 100644 index 99a5ba55719..00000000000 --- a/tests/cases/fourslash/findAllRefsIII.ts +++ /dev/null @@ -1,16 +0,0 @@ -/// - -// @Filename: /a.ts -////function [|{| "isWriteAccess": true, "isDefinition": true |}f|]() {}; -////export { [|{| "isWriteAccess": true, "isDefinition": true |}f|] as [|{| "isWriteAccess": true, "isDefinition": true |}g|] }; - -// @Filename: /b.ts -////import { [|{| "isWriteAccess": true, "isDefinition": true |}g|] } from "./a"; - -verify.noErrors(); -const [f0, f1, g0, g1] = test.ranges(); - -const fs = { definition: "function f(): void", ranges: [f0, f1] }; -const gs0 = { definition: "import g", ranges: [g0] }; -const gs1 = { definition: "import g", ranges: [g1] }; -verify.referenceGroups(f0, [fs, gs0, gs1]); diff --git a/tests/cases/fourslash/findAllRefsReExportRightNameWrongSymbol.ts b/tests/cases/fourslash/findAllRefsReExportRightNameWrongSymbol.ts new file mode 100644 index 00000000000..c9d42e53d4e --- /dev/null +++ b/tests/cases/fourslash/findAllRefsReExportRightNameWrongSymbol.ts @@ -0,0 +1,37 @@ +/// + +// @Filename: /a.ts +////export const [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 0; + +// @Filename: /b.ts +////export const [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 0; + +//@Filename: /c.ts +////export { [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./b"; +////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./a"; +////[|x|]; + +// @Filename: /d.ts +////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./c"; + +verify.noErrors(); +const [a, b, cFromB, cFromA, cUse, d] = test.ranges(); +const cFromARanges = [cFromA, cUse]; + +const aGroup = { definition: "const x: 0", ranges: [a] }; +const cFromAGroup = { definition: "import x", ranges: cFromARanges }; + +verify.referenceGroups(a, [aGroup, cFromAGroup]); + +const bGroup = { definition: "const x: 0", ranges: [b] }; +const cFromBGroup = { definition: "import x", ranges: [cFromB] }; +const dGroup = { definition: "import x", ranges: [d] }; +verify.referenceGroups(b, [bGroup, cFromBGroup, dGroup]); + +verify.referenceGroups(cFromB, [cFromBGroup, dGroup, bGroup]); +verify.referenceGroups(cFromARanges, [cFromAGroup, aGroup]); + +verify.referenceGroups(d, [dGroup, cFromBGroup, bGroup]); + +verify.rangesAreRenameLocations([a, cFromA, cUse]); +verify.rangesAreRenameLocations([b, cFromB, d]); diff --git a/tests/cases/fourslash/findAllRefsRenameImportWithSameName.ts b/tests/cases/fourslash/findAllRefsRenameImportWithSameName.ts new file mode 100644 index 00000000000..c1a49b3b5b0 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsRenameImportWithSameName.ts @@ -0,0 +1,20 @@ +/// + +// @Filename: /a.ts +////export const [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 0; + +//@Filename: /b.ts +////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|] as [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./a"; +////[|x|]; + +verify.noErrors(); +const [r0, r1, r2, r3] = test.ranges(); +const aRanges = [r0, r1]; +const bRanges = [r2, r3]; +const aGroup = { definition: "const x: 0", ranges: aRanges }; +const bGroup = { definition: "import x", ranges: bRanges }; +verify.referenceGroups(aRanges, [aGroup, bGroup]); +verify.referenceGroups(bRanges, [bGroup]); + +verify.rangesAreRenameLocations(aRanges); +verify.rangesAreRenameLocations(aRanges); From 151023c69b71202faa6ad4631f643d5c0180df1c Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Thu, 16 Feb 2017 06:59:17 -0800 Subject: [PATCH 05/35] Fix and consolidate tsx rename tests --- tests/cases/fourslash/tsxRename10.ts | 40 ---------------------------- tests/cases/fourslash/tsxRename11.ts | 39 --------------------------- tests/cases/fourslash/tsxRename12.ts | 39 --------------------------- tests/cases/fourslash/tsxRename13.ts | 39 --------------------------- tests/cases/fourslash/tsxRename6.ts | 7 +---- tests/cases/fourslash/tsxRename7.ts | 7 +---- tests/cases/fourslash/tsxRename8.ts | 7 +---- tests/cases/fourslash/tsxRename9.ts | 19 +++++-------- 8 files changed, 10 insertions(+), 187 deletions(-) delete mode 100644 tests/cases/fourslash/tsxRename10.ts delete mode 100644 tests/cases/fourslash/tsxRename11.ts delete mode 100644 tests/cases/fourslash/tsxRename12.ts delete mode 100644 tests/cases/fourslash/tsxRename13.ts diff --git a/tests/cases/fourslash/tsxRename10.ts b/tests/cases/fourslash/tsxRename10.ts deleted file mode 100644 index 091f5aa976f..00000000000 --- a/tests/cases/fourslash/tsxRename10.ts +++ /dev/null @@ -1,40 +0,0 @@ -/// - -//@Filename: file.tsx -// @jsx: preserve -// @noLib: true - -//// declare module JSX { -//// interface Element { } -//// interface IntrinsicElements { -//// } -//// interface ElementAttributesProperty { props; } -//// } -//// interface ClickableProps { -//// children?: string; -//// className?: string; -//// } -//// interface ButtonProps extends ClickableProps { -//// onClick(event?: React.MouseEvent): void; -//// } -//// interface LinkProps extends ClickableProps { -//// [|goTo|]: string; -//// } -//// declare function MainButton(buttonProps: ButtonProps): JSX.Element; -//// declare function MainButton(linkProps: LinkProps): JSX.Element; -//// declare function MainButton(props: ButtonProps | LinkProps): JSX.Element; -//// let opt = ; -//// let opt = ; -//// let opt = {}} />; -//// let opt = {}} ignore-prop />; -//// let opt = ; -//// let opt = ; -//// let opt = ; - - -let ranges = test.ranges(); -verify.assertHasRanges(ranges); -for (let range of ranges) { - goTo.position(range.start); - verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); -} \ No newline at end of file diff --git a/tests/cases/fourslash/tsxRename11.ts b/tests/cases/fourslash/tsxRename11.ts deleted file mode 100644 index 97933dd0cc9..00000000000 --- a/tests/cases/fourslash/tsxRename11.ts +++ /dev/null @@ -1,39 +0,0 @@ -/// - -//@Filename: file.tsx -// @jsx: preserve -// @noLib: true - -//// declare module JSX { -//// interface Element { } -//// interface IntrinsicElements { -//// } -//// interface ElementAttributesProperty { props; } -//// } -//// interface ClickableProps { -//// children?: string; -//// className?: string; -//// } -//// interface ButtonProps extends ClickableProps { -//// [|onClick|](event?: React.MouseEvent): void; -//// } -//// interface LinkProps extends ClickableProps { -//// goTo: string; -//// } -//// declare function MainButton(buttonProps: ButtonProps): JSX.Element; -//// declare function MainButton(linkProps: LinkProps): JSX.Element; -//// declare function MainButton(props: ButtonProps | LinkProps): JSX.Element; -//// let opt = ; -//// let opt = ; -//// let opt = {}} />; -//// let opt = {}} ignore-prop />; -//// let opt = ; -//// let opt = ; - - -let ranges = test.ranges(); -verify.assertHasRanges(ranges); -for (let range of ranges) { - goTo.position(range.start); - verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); -} \ No newline at end of file diff --git a/tests/cases/fourslash/tsxRename12.ts b/tests/cases/fourslash/tsxRename12.ts deleted file mode 100644 index 30e6b506f4d..00000000000 --- a/tests/cases/fourslash/tsxRename12.ts +++ /dev/null @@ -1,39 +0,0 @@ -/// - -//@Filename: file.tsx -// @jsx: preserve -// @noLib: true - -//// declare module JSX { -//// interface Element { } -//// interface IntrinsicElements { -//// } -//// interface ElementAttributesProperty { props; } -//// } -//// interface ClickableProps { -//// children?: string; -//// className?: string; -//// } -//// interface ButtonProps extends ClickableProps { -//// onClick(event?: React.MouseEvent): void; -//// } -//// interface LinkProps extends ClickableProps { -//// goTo: string; -//// } -//// declare function MainButton(buttonProps: ButtonProps): JSX.Element; -//// declare function MainButton(linkProps: LinkProps): JSX.Element; -//// declare function MainButton(props: ButtonProps | LinkProps): JSX.Element; -//// let opt = ; -//// let opt = ; -//// let opt = {}} />; -//// let opt = {}} ignore-prop />; -//// let opt = ; -//// let opt = ; - - -let ranges = test.ranges(); -verify.assertHasRanges(ranges); -for (let range of ranges) { - goTo.position(range.start); - verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); -} \ No newline at end of file diff --git a/tests/cases/fourslash/tsxRename13.ts b/tests/cases/fourslash/tsxRename13.ts deleted file mode 100644 index 02d0fb1b3dd..00000000000 --- a/tests/cases/fourslash/tsxRename13.ts +++ /dev/null @@ -1,39 +0,0 @@ -/// - -//@Filename: file.tsx -// @jsx: preserve -// @noLib: true - -//// declare module JSX { -//// interface Element { } -//// interface IntrinsicElements { -//// } -//// interface ElementAttributesProperty { props; } -//// } -//// interface ClickableProps { -//// children?: string; -//// className?: string; -//// } -//// interface ButtonProps extends ClickableProps { -//// onClick(event?: React.MouseEvent): void; -//// } -//// interface LinkProps extends ClickableProps { -//// goTo: string; -//// } -//// declare function MainButton(buttonProps: ButtonProps): JSX.Element; -//// declare function MainButton(linkProps: LinkProps): JSX.Element; -//// declare function MainButton(props: ButtonProps | LinkProps): JSX.Element; -//// let opt = ; -//// let opt = ; -//// let opt = {}} />; -//// let opt = {}} [|ignore-prop|] />; -//// let opt = ; -//// let opt = ; - - -let ranges = test.ranges(); -verify.assertHasRanges(ranges); -for (let range of ranges) { - goTo.position(range.start); - verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); -} \ No newline at end of file diff --git a/tests/cases/fourslash/tsxRename6.ts b/tests/cases/fourslash/tsxRename6.ts index 59bc3f48009..6f999c12760 100644 --- a/tests/cases/fourslash/tsxRename6.ts +++ b/tests/cases/fourslash/tsxRename6.ts @@ -22,9 +22,4 @@ //// let opt3 = <[|Opt|] wrong />; //// let opt4 = <[|Opt|] propx={100} propString="hi" />; -let ranges = test.ranges(); -verify.assertHasRanges(ranges); -for (let range of ranges) { - goTo.position(range.start); - verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); -} \ No newline at end of file +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/tsxRename7.ts b/tests/cases/fourslash/tsxRename7.ts index b5d05e49bd3..5533db1b4db 100644 --- a/tests/cases/fourslash/tsxRename7.ts +++ b/tests/cases/fourslash/tsxRename7.ts @@ -21,9 +21,4 @@ //// let opt2 = ; //// let opt3 = ; -let ranges = test.ranges(); -verify.assertHasRanges(ranges); -for (let range of ranges) { - goTo.position(range.start); - verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); -} \ No newline at end of file +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/tsxRename8.ts b/tests/cases/fourslash/tsxRename8.ts index 48bbff0d88e..a75c2833bb2 100644 --- a/tests/cases/fourslash/tsxRename8.ts +++ b/tests/cases/fourslash/tsxRename8.ts @@ -23,9 +23,4 @@ //// let opt3 = ; //// let opt4 = ; -let ranges = test.ranges(); -verify.assertHasRanges(ranges); -for (let range of ranges) { - goTo.position(range.start); - verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); -} \ No newline at end of file +verify.rangesAreRenameLocations(); diff --git a/tests/cases/fourslash/tsxRename9.ts b/tests/cases/fourslash/tsxRename9.ts index 4d132f5eac9..b39b009634d 100644 --- a/tests/cases/fourslash/tsxRename9.ts +++ b/tests/cases/fourslash/tsxRename9.ts @@ -15,24 +15,19 @@ //// className?: string; //// } //// interface ButtonProps extends ClickableProps { -//// onClick(event?: React.MouseEvent): void; +//// [|onClick|](event?: React.MouseEvent): void; //// } //// interface LinkProps extends ClickableProps { -//// goTo: string; +//// [|goTo|]: string; //// } //// declare function [|MainButton|](buttonProps: ButtonProps): JSX.Element; //// declare function [|MainButton|](linkProps: LinkProps): JSX.Element; //// declare function [|MainButton|](props: ButtonProps | LinkProps): JSX.Element; //// let opt = <[|MainButton|] />; //// let opt = <[|MainButton|] children="chidlren" />; -//// let opt = <[|MainButton|] onClick={()=>{}} />; -//// let opt = <[|MainButton|] onClick={()=>{}} ignore-prop />; -//// let opt = <[|MainButton|] goTo="goTo" />; -//// let opt = <[|MainButton|] wrong />; +//// let opt = <[|MainButton|] [|onClick|]={()=>{}} />; +//// let opt = <[|MainButton|] [|onClick|]={()=>{}} [|ignore-prop|] />; +//// let opt = <[|MainButton|] [|goTo|]="goTo" />; +//// let opt = <[|MainButton|] [|wrong|] />; -let ranges = test.ranges(); -verify.assertHasRanges(ranges); -for (let range of ranges) { - goTo.position(range.start); - verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); -} \ No newline at end of file +verify.rangesWithSameTextAreRenameLocations(); From 94f6839aec38541651caba820d4965ba1deb73c2 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Fri, 17 Mar 2017 09:00:30 -0700 Subject: [PATCH 06/35] Factor out FindAllReferences.Core and use Definition/Entry to allow findReferencedSymbols and getImplementationsAtPosition to return different results --- src/compiler/types.ts | 3 - src/harness/fourslash.ts | 4 +- src/services/documentHighlights.ts | 12 +- src/services/findAllReferences.ts | 438 +++++++++++++++++------------ src/services/importTracker.ts | 2 +- src/services/types.ts | 1 + src/services/utilities.ts | 15 + 7 files changed, 278 insertions(+), 197 deletions(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index d10025beb17..b57bd767dd9 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1849,7 +1849,6 @@ namespace ts { } export interface ExternalModuleReference extends Node { - parent: ImportEqualsDeclaration; kind: SyntaxKind.ExternalModuleReference; parent?: ImportEqualsDeclaration; expression?: Expression; @@ -1909,7 +1908,6 @@ namespace ts { } export interface NamedExports extends Node { - parent: ExportDeclaration; kind: SyntaxKind.NamedExports; parent?: ExportDeclaration; elements: NodeArray; @@ -1925,7 +1923,6 @@ namespace ts { } export interface ExportSpecifier extends Declaration { - parent: NamedExports; kind: SyntaxKind.ExportSpecifier; parent?: NamedExports; propertyName?: Identifier; // Name preceding "as" keyword (or undefined when "as" is absent) diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index 6872f375d8f..8643e5da3f0 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -992,7 +992,7 @@ namespace FourSlash { for (const startRange of toArray(startRanges)) { this.goToRangeStart(startRange); - const fullActual = this.findReferencesAtCaret().map(({ definition, references }) => ({ + const fullActual = ts.map(this.findReferencesAtCaret(), ({ definition, references }) => ({ definition: definition.displayParts.map(d => d.text).join(""), ranges: references })); @@ -2383,7 +2383,7 @@ namespace FourSlash { else { if (actual === undefined) { this.raiseError(`${name} failed - expected the template {newText: "${expected.newText}", caretOffset: "${expected.caretOffset}"} but got nothing instead`); - + } if (actual.newText !== expected.newText) { diff --git a/src/services/documentHighlights.ts b/src/services/documentHighlights.ts index fcf7d0848d1..047e665d7a5 100644 --- a/src/services/documentHighlights.ts +++ b/src/services/documentHighlights.ts @@ -21,19 +21,15 @@ namespace ts.DocumentHighlights { return referenceEntries && convertReferencedSymbols(referenceEntries); } - function convertReferencedSymbols(referenceEntries: ReferenceEntry[]): DocumentHighlights[] { + function convertReferencedSymbols(referenceEntries: FindAllReferences.Entry[]): DocumentHighlights[] { const fileNameToDocumentHighlights = createMap(); - for (const referenceEntry of referenceEntries) { - const fileName = referenceEntry.fileName; + for (const entry of referenceEntries) { + const { fileName, span } = FindAllReferences.toHighlightSpan(entry); let highlightSpans = fileNameToDocumentHighlights.get(fileName); if (!highlightSpans) { fileNameToDocumentHighlights.set(fileName, highlightSpans = []); } - - highlightSpans.push({ - textSpan: referenceEntry.textSpan, - kind: referenceEntry.isWriteAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference - }); + highlightSpans.push(span); } return arrayFrom(fileNameToDocumentHighlights.entries(), ([fileName, highlightSpans ]) => ({ fileName, highlightSpans })); diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index bf4a6b5b5f1..d5d118f0b75 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -2,6 +2,33 @@ /* @internal */ namespace ts.FindAllReferences { + export interface SymbolAndEntries { + definition: Definition | undefined; + references: Entry[]; + } + + type Definition = + | { type: "symbol"; symbol: Symbol; node: Node; } + | { type: "label"; node: Identifier; } + | { type: "keyword"; node: ts.Node; } + | { type: "this"; node: ts.Node; } + | { type: "string"; node: ts.StringLiteral }; + + export type Entry = NodeEntry | SpanEntry; + export interface NodeEntry { + type: "node"; + node: Node; + isInString: boolean; + } + interface SpanEntry { + type: "span"; + fileName: string; + textSpan: TextSpan; + } + export function nodeEntry(node: ts.Node, isInString = false): NodeEntry { + return { type: "node", node, isInString }; + } + export interface Options { readonly findInStrings?: boolean; readonly findInComments?: boolean; @@ -16,29 +43,41 @@ namespace ts.FindAllReferences { export function findReferencedSymbols(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number): ReferencedSymbol[] | undefined { const referencedSymbols = findAllReferencedSymbols(checker, cancellationToken, sourceFiles, sourceFile, position); - // Only include referenced symbols that have a valid definition. - return filter(referencedSymbols, rs => !!rs.definition); + + if (!referencedSymbols || !referencedSymbols.length) { + return undefined; + } + + const out: ReferencedSymbol[] = []; + for (const { definition, references } of referencedSymbols) { + // Only include referenced symbols that have a valid definition. + if (definition) { + out.push({ definition: definitionToReferencedSymbolDefinitionInfo(definition, checker), references: references.map(toReferenceEntry) }); + } + } + + return out; } export function getImplementationsAtPosition(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number): ImplementationLocation[] { const node = getTouchingPropertyName(sourceFile, position); const referenceEntries = getImplementationReferenceEntries(checker, cancellationToken, sourceFiles, node); - return map(referenceEntries, ({ textSpan, fileName }) => ({ textSpan, fileName })); + return map(referenceEntries, entry => toImplementationLocation(entry, checker)); } - function getImplementationReferenceEntries(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], node: Node): ReferenceEntry[] { + function getImplementationReferenceEntries(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], node: Node): Entry[] | undefined { // If invoked directly on a shorthand property assignment, then return // the declaration of the symbol being assigned (not the symbol being assigned to). if (node.parent.kind === SyntaxKind.ShorthandPropertyAssignment) { - const result: ReferenceEntry[] = []; - getReferenceEntriesForShorthandPropertyAssignment(node, typeChecker, node => result.push(getReferenceEntryFromNode(node))); + const result: NodeEntry[] = []; + Core.getReferenceEntriesForShorthandPropertyAssignment(node, typeChecker, node => result.push(nodeEntry(node))); return result; } else if (node.kind === SyntaxKind.SuperKeyword || isSuperProperty(node.parent)) { // References to and accesses on the super keyword only have one possible implementation, so no // need to "Find all References" const symbol = typeChecker.getSymbolAtLocation(node); - return symbol.valueDeclaration && [getReferenceEntryFromNode(symbol.valueDeclaration)]; + return symbol.valueDeclaration && [nodeEntry(symbol.valueDeclaration)]; } else { // Perform "Find all References" and retrieve only those that are implementations @@ -47,30 +86,188 @@ namespace ts.FindAllReferences { } export function findReferencedEntries(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, options?: Options): ReferenceEntry[] | undefined { - return flattenEntries(findAllReferencedSymbols(checker, cancellationToken, sourceFiles, sourceFile, position, options)); + const x = flattenEntries(findAllReferencedSymbols(checker, cancellationToken, sourceFiles, sourceFile, position, options)); + return map(x, toReferenceEntry); } - function findAllReferencedSymbols(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, options?: Options): ReferencedSymbol[] | undefined { + export function getReferenceEntriesForNode(node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options = {}): Entry[] | undefined { + return flattenEntries(Core.getReferencedSymbolsForNode(node, sourceFiles, checker, cancellationToken, options)); + } + + function findAllReferencedSymbols(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, options?: Options): SymbolAndEntries[] | undefined { const node = getTouchingPropertyName(sourceFile, position, /*includeJsDocComment*/ true); - return getReferencedSymbolsForNode(node, sourceFiles, checker, cancellationToken, options); + return Core.getReferencedSymbolsForNode(node, sourceFiles, checker, cancellationToken, options); } - export function getReferenceEntriesForNode(node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options = {}): ReferenceEntry[] | undefined { - return flattenEntries(getReferencedSymbolsForNode(node, sourceFiles, checker, cancellationToken, options)); - } - - function flattenEntries(referenceSymbols: ReferencedSymbol[]): ReferenceEntry[] { + function flattenEntries(referenceSymbols: SymbolAndEntries[]): Entry[] { return referenceSymbols && flatMap(referenceSymbols, r => r.references); } + function definitionToReferencedSymbolDefinitionInfo(def: Definition, checker: TypeChecker): ReferencedSymbolDefinitionInfo | undefined { + const info = (() => { + switch (def.type) { + case "symbol": { + const { symbol, node } = def; + const declarations = symbol.declarations; + if (!declarations || declarations.length === 0) { + return undefined; + } + const { displayParts, kind } = getDefinitionKindAndDisplayParts(symbol, node, checker); + const name = displayParts.map(p => p.text).join(""); + return { node, name, kind, displayParts }; + } + case "label": { + const { node } = def; + return { node, name: node.text, kind: ScriptElementKind.label, displayParts: [displayPart(node.text, SymbolDisplayPartKind.text)] }; + } + case "keyword": { + const { node } = def; + const name = tokenToString(node.kind); + return { node, name, kind: ScriptElementKind.keyword, displayParts: [{ text: name, kind: ScriptElementKind.keyword }] }; + } + case "this": { + const { node } = def; + const symbol = checker.getSymbolAtLocation(node); + const displayParts = symbol && SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind( + checker, symbol, node.getSourceFile(), getContainerNode(node), node).displayParts; + return { node, name: "this", kind: ScriptElementKind.variableElement, displayParts }; + } + case "string": { + const { node } = def; + return { node, name: node.text, kind: ScriptElementKind.variableElement, displayParts: [displayPart(getTextOfNode(node), SymbolDisplayPartKind.stringLiteral)] }; + } + } + })(); + + if (!info) { + return undefined; + } + + const { node, name, kind, displayParts } = info; + const sourceFile = node.getSourceFile(); + return { + containerKind: "", + containerName: "", + fileName: sourceFile.fileName, + kind, + name, + textSpan: createTextSpanFromNode(node, sourceFile), + displayParts + }; + } + + function getDefinitionKindAndDisplayParts(symbol: Symbol, node: Node, checker: TypeChecker): { displayParts: SymbolDisplayPart[], kind: string } { + const { displayParts, symbolKind } = + SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, node.getSourceFile(), getContainerNode(node), node); + return { displayParts, kind: symbolKind }; + } + + function toReferenceEntry(entry: Entry): ReferenceEntry { + if (entry.type === "span") { + return { textSpan: entry.textSpan, fileName: entry.fileName, isWriteAccess: false, isDefinition: false }; + } + + const { node, isInString } = entry; + return { + fileName: node.getSourceFile().fileName, + textSpan: getTextSpan(node), + isWriteAccess: isWriteAccess(node), + isDefinition: isDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node), + isInString: isInString ? true : undefined + }; + } + + function toImplementationLocation(entry: Entry, checker: ts.TypeChecker): ImplementationLocation { + if (entry.type === "node") { + const { node } = entry; + return { textSpan: getTextSpan(node), fileName: node.getSourceFile().fileName, ...implementationKindDisplayParts(node, checker) }; + } else { + const { textSpan, fileName } = entry; + return { textSpan, fileName, kind: ScriptElementKind.unknown, displayParts: [] }; + } + } + + function implementationKindDisplayParts(node: ts.Node, checker: ts.TypeChecker): { kind: string, displayParts: SymbolDisplayPart[] } { + const symbol = checker.getSymbolAtLocation(isDeclaration(node) && node.name ? node.name : node); + if (symbol) { + return getDefinitionKindAndDisplayParts(symbol, node, checker); + } + else if (node.kind === SyntaxKind.ObjectLiteralExpression) { + return { + kind: ScriptElementKind.interfaceElement, + displayParts: [punctuationPart(SyntaxKind.OpenParenToken), textPart("object literal"), punctuationPart(SyntaxKind.CloseParenToken)] + }; + } + else if (node.kind === SyntaxKind.ClassExpression) { + return { + kind: ScriptElementKind.localClassElement, + displayParts: [punctuationPart(SyntaxKind.OpenParenToken), textPart("anonymous local class"), punctuationPart(SyntaxKind.CloseParenToken)] + }; + } + else { + return { kind: getNodeKind(node), displayParts: [] }; + } + } + + export function toHighlightSpan(entry: FindAllReferences.Entry): { fileName: string, span: HighlightSpan } { + if (entry.type === "span") { + const { fileName, textSpan } = entry; + return { fileName, span: { textSpan, kind: HighlightSpanKind.reference } }; + } + + const { node, isInString } = entry; + const fileName = entry.node.getSourceFile().fileName; + const writeAccess = isWriteAccess(node); + const span: HighlightSpan = { + textSpan: getTextSpan(node), + kind: writeAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference, + isInString: isInString ? true : undefined + }; + return { fileName, span }; + } + + function getTextSpan(node: Node): TextSpan { + let start = node.getStart(); + let end = node.getEnd(); + if (node.kind === SyntaxKind.StringLiteral) { + start += 1; + end -= 1; + } + return createTextSpanFromBounds(start, end); + } + + /** A node is considered a writeAccess iff it is a name of a declaration or a target of an assignment */ + function isWriteAccess(node: Node): boolean { + if (node.kind === SyntaxKind.Identifier && isDeclarationName(node)) { + return true; + } + + const parent = node.parent; + if (parent) { + if (parent.kind === SyntaxKind.PostfixUnaryExpression || parent.kind === SyntaxKind.PrefixUnaryExpression) { + return true; + } + else if (parent.kind === SyntaxKind.BinaryExpression && (parent).left === node) { + const operator = (parent).operatorToken.kind; + return SyntaxKind.FirstAssignment <= operator && operator <= SyntaxKind.LastAssignment; + } + } + + return false; + } +} + +/** Encapsulates the core find-all-references algorithm. */ +/* @internal */ +namespace ts.FindAllReferences.Core { /** Core find-all-references algorithm. Handles special cases before delegating to `getReferencedSymbolsForSymbol`. */ - function getReferencedSymbolsForNode(node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options = {}): ReferencedSymbol[] | undefined { + export function getReferencedSymbolsForNode(node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options = {}): SymbolAndEntries[] | undefined { if (node.kind === ts.SyntaxKind.SourceFile) { return undefined; } if (!options.implementations) { - const special = getReferencedSymbolsSpecial(node, sourceFiles, checker, cancellationToken); + const special = getReferencedSymbolsSpecial(node, sourceFiles, cancellationToken); if (special) { return special; } @@ -97,7 +294,7 @@ namespace ts.FindAllReferences { } /** getReferencedSymbols for special node kinds. */ - function getReferencedSymbolsSpecial(node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] | undefined { + function getReferencedSymbolsSpecial(node: Node, sourceFiles: SourceFile[], cancellationToken: CancellationToken): SymbolAndEntries[] | undefined { if (isTypeKeyword(node.kind)) { return getAllReferencesForKeyword(sourceFiles, node.kind, cancellationToken); } @@ -117,24 +314,24 @@ namespace ts.FindAllReferences { } if (isThis(node)) { - return getReferencesForThisKeyword(node, sourceFiles, checker, cancellationToken); + return getReferencesForThisKeyword(node, sourceFiles, cancellationToken); } if (node.kind === SyntaxKind.SuperKeyword) { - return getReferencesForSuperKeyword(node, checker, cancellationToken); + return getReferencesForSuperKeyword(node, cancellationToken); } return undefined; } /** Core find-all-references algorithm for a normal symbol. */ - function getReferencedSymbolsForSymbol(symbol: Symbol, node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options): ReferencedSymbol[] { + function getReferencedSymbolsForSymbol(symbol: Symbol, node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options): SymbolAndEntries[] { symbol = skipPastExportOrImportSpecifier(symbol, node, checker); // Compute the meaning from the location and the symbol it references const searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), symbol.declarations); - const result: ReferencedSymbol[] = []; + const result: SymbolAndEntries[] = []; const state = createState(sourceFiles, node, checker, cancellationToken, searchMeaning, options, result); const search = state.createSearch(node, symbol, /*comingFrom*/undefined, { allSearchSymbols: populateSearchSymbolSet(symbol, node, checker, options.implementations) }); @@ -248,8 +445,8 @@ namespace ts.FindAllReferences { markSeenReExportRHS(rhs: Identifier): boolean; } - function createState(sourceFiles: SourceFile[], originalLocation: Node, checker: TypeChecker, cancellationToken: CancellationToken, searchMeaning: SemanticMeaning, options: Options, result: Push): State { - const symbolIdToReferences: ReferenceEntry[][] = []; + function createState(sourceFiles: SourceFile[], originalLocation: Node, checker: TypeChecker, cancellationToken: CancellationToken, searchMeaning: SemanticMeaning, options: Options, result: Push): State { + const symbolIdToReferences: Entry[][] = []; const inheritsFromCache = createMap(); // Source file ID → symbol ID → Whether the symbol has been searched for in the source file. const sourceFileToSeenSymbols: Array> = []; @@ -284,15 +481,15 @@ namespace ts.FindAllReferences { let references = symbolIdToReferences[symbolId]; if (!references) { references = symbolIdToReferences[symbolId] = []; - result.push({ definition: getDefinition(referenceSymbol, searchLocation, checker), references }); + result.push({ definition: { type: "symbol", symbol: referenceSymbol, node: searchLocation }, references }); } - return node => references.push(getReferenceEntryFromNode(node)); + return node => references.push({ type: "node", node, isInString: false }); } function addStringOrCommentReference(fileName: string, textSpan: TextSpan): void { result.push({ definition: undefined, - references: [{ fileName, textSpan, isWriteAccess: false, isDefinition: false }] + references: [{ type: "span", fileName, textSpan }] }); } @@ -361,26 +558,6 @@ namespace ts.FindAllReferences { return getNameTable(sourceFile).get(escapedName) !== undefined; } - function getDefinition(symbol: Symbol, node: Node, checker: TypeChecker): ReferencedSymbolDefinitionInfo | undefined { - const declarations = symbol.declarations; - if (!declarations || declarations.length === 0) { - return undefined; - } - - const { displayParts, symbolKind } = - SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, node.getSourceFile(), getContainerNode(node), node); - const name = displayParts.map(p => p.text).join(""); - return { - containerKind: "", - containerName: "", - name, - kind: symbolKind, - fileName: declarations[0].getSourceFile().fileName, - textSpan: createTextSpan(declarations[0].getStart(), 0), - displayParts - }; - } - function getPropertySymbolOfDestructuringAssignment(location: Node, checker: TypeChecker): Symbol | undefined { return isArrayLiteralOrObjectLiteralDestructuringPattern(location.parent.parent) && checker.getPropertySymbolOfDestructuringAssignment(location); @@ -509,8 +686,8 @@ namespace ts.FindAllReferences { return positions; } - function getLabelReferencesInNode(container: Node, targetLabel: Identifier, cancellationToken: CancellationToken): ReferencedSymbol[] { - const references: ReferenceEntry[] = []; + function getLabelReferencesInNode(container: Node, targetLabel: Identifier, cancellationToken: CancellationToken): SymbolAndEntries[] { + const references: Entry[] = []; const sourceFile = container.getSourceFile(); const labelName = targetLabel.text; const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, labelName, container.getStart(), container.getEnd(), cancellationToken); @@ -525,21 +702,11 @@ namespace ts.FindAllReferences { // Only pick labels that are either the target label, or have a target that is the target label if (node === targetLabel || (isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel)) { - references.push(getReferenceEntryFromNode(node)); + references.push(nodeEntry(node)); } } - const definition: ReferencedSymbolDefinitionInfo = { - containerKind: "", - containerName: "", - fileName: targetLabel.getSourceFile().fileName, - kind: ScriptElementKind.label, - name: labelName, - textSpan: createTextSpanFromNode(targetLabel, sourceFile), - displayParts: [displayPart(labelName, SymbolDisplayPartKind.text)] - }; - - return [{ definition, references }]; + return [{ definition: { type: "label", node: targetLabel }, references }]; } function isValidReferencePosition(node: Node, searchSymbolName: string): boolean { @@ -561,41 +728,22 @@ namespace ts.FindAllReferences { } } - function getAllReferencesForKeyword(sourceFiles: SourceFile[], keywordKind: ts.SyntaxKind, cancellationToken: CancellationToken): ReferencedSymbol[] { - const name = tokenToString(keywordKind); - const references: ReferenceEntry[] = []; + function getAllReferencesForKeyword(sourceFiles: SourceFile[], keywordKind: ts.SyntaxKind, cancellationToken: CancellationToken): SymbolAndEntries[] { + const references: NodeEntry[] = []; for (const sourceFile of sourceFiles) { cancellationToken.throwIfCancellationRequested(); - addReferencesForKeywordInFile(sourceFile, keywordKind, name, cancellationToken, references); + addReferencesForKeywordInFile(sourceFile, keywordKind, tokenToString(keywordKind), cancellationToken, references); } - - if (!references.length) return undefined; - - const definition: ReferencedSymbolDefinitionInfo = { - containerKind: "", - containerName: "", - fileName: references[0].fileName, - kind: ScriptElementKind.keyword, - name, - textSpan: references[0].textSpan, - displayParts: [{ text: name, kind: ScriptElementKind.keyword }] - }; - - return [{ definition, references }]; + return references.length ? [{ definition: { type: "keyword", node: references[0].node }, references }] : undefined; } - function addReferencesForKeywordInFile(sourceFile: SourceFile, kind: SyntaxKind, searchText: string, cancellationToken: CancellationToken, references: Push): void { + function addReferencesForKeywordInFile(sourceFile: SourceFile, kind: SyntaxKind, searchText: string, cancellationToken: CancellationToken, references: Push): void { const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, sourceFile.getStart(), sourceFile.getEnd(), cancellationToken); for (const position of possiblePositions) { cancellationToken.throwIfCancellationRequested(); const referenceLocation = getTouchingPropertyName(sourceFile, position); if (referenceLocation.kind === kind) { - references.push({ - textSpan: createTextSpanFromNode(referenceLocation), - fileName: sourceFile.fileName, - isWriteAccess: false, - isDefinition: false, - }); + references.push(nodeEntry(referenceLocation)); } } } @@ -683,7 +831,7 @@ namespace ts.FindAllReferences { } if (!propertyName) { - addRef() + addRef(); } else if (referenceLocation === propertyName) { // For `export { foo as bar } from "baz"`, "`foo`" will be added from the singleReferences for import searches of the original export. @@ -1034,7 +1182,7 @@ namespace ts.FindAllReferences { } } - function getReferencesForSuperKeyword(superKeyword: Node, checker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] { + function getReferencesForSuperKeyword(superKeyword: Node, cancellationToken: CancellationToken): SymbolAndEntries[] { let searchSpaceNode = getSuperContainer(superKeyword, /*stopOnFunctions*/ false); if (!searchSpaceNode) { return undefined; @@ -1057,7 +1205,7 @@ namespace ts.FindAllReferences { return undefined; } - const references: ReferenceEntry[] = []; + const references: Entry[] = []; const sourceFile = searchSpaceNode.getSourceFile(); const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "super", searchSpaceNode.getStart(), searchSpaceNode.getEnd(), cancellationToken); @@ -1076,15 +1224,14 @@ namespace ts.FindAllReferences { // Now make sure the owning class is the same as the search-space // and has the same static qualifier as the original 'super's owner. if (container && (ModifierFlags.Static & getModifierFlags(container)) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) { - references.push(getReferenceEntryFromNode(node)); + references.push(nodeEntry(node)); } } - const definition = getDefinition(searchSpaceNode.symbol, superKeyword, checker); - return [{ definition, references }]; + return [{ definition: { type: "symbol", symbol: searchSpaceNode.symbol, node: superKeyword }, references }]; } - function getReferencesForThisKeyword(thisOrSuperKeyword: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] { + function getReferencesForThisKeyword(thisOrSuperKeyword: Node, sourceFiles: SourceFile[], cancellationToken: CancellationToken): SymbolAndEntries[] { let searchSpaceNode = getThisContainer(thisOrSuperKeyword, /* includeArrowFunctions */ false); // Whether 'this' occurs in a static context within a class. @@ -1119,7 +1266,7 @@ namespace ts.FindAllReferences { return undefined; } - const references: ReferenceEntry[] = []; + const references: Entry[] = []; let possiblePositions: number[]; if (searchSpaceNode.kind === SyntaxKind.SourceFile) { @@ -1134,25 +1281,12 @@ namespace ts.FindAllReferences { getThisReferencesInFile(sourceFile, searchSpaceNode, possiblePositions, references); } - const thisOrSuperSymbol = checker.getSymbolAtLocation(thisOrSuperKeyword); - - const displayParts = thisOrSuperSymbol && SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind( - checker, thisOrSuperSymbol, thisOrSuperKeyword.getSourceFile(), getContainerNode(thisOrSuperKeyword), thisOrSuperKeyword).displayParts; - return [{ - definition: { - containerKind: "", - containerName: "", - fileName: thisOrSuperKeyword.getSourceFile().fileName, - kind: ScriptElementKind.variableElement, - name: "this", - textSpan: createTextSpanFromNode(thisOrSuperKeyword), - displayParts - }, - references: references + definition: { type: "this", node: thisOrSuperKeyword }, + references }]; - function getThisReferencesInFile(sourceFile: SourceFile, searchSpaceNode: Node, possiblePositions: number[], result: ReferenceEntry[]): void { + function getThisReferencesInFile(sourceFile: SourceFile, searchSpaceNode: Node, possiblePositions: number[], result: Entry[]): void { forEach(possiblePositions, position => { cancellationToken.throwIfCancellationRequested(); @@ -1167,13 +1301,13 @@ namespace ts.FindAllReferences { case SyntaxKind.FunctionExpression: case SyntaxKind.FunctionDeclaration: if (searchSpaceNode.symbol === container.symbol) { - result.push(getReferenceEntryFromNode(node)); + result.push(nodeEntry(node)); } break; case SyntaxKind.MethodDeclaration: case SyntaxKind.MethodSignature: if (isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) { - result.push(getReferenceEntryFromNode(node)); + result.push(nodeEntry(node)); } break; case SyntaxKind.ClassExpression: @@ -1181,12 +1315,12 @@ namespace ts.FindAllReferences { // Make sure the container belongs to the same class // and has the appropriate static modifier from the original container. if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (getModifierFlags(container) & ModifierFlags.Static) === staticFlag) { - result.push(getReferenceEntryFromNode(node)); + result.push(nodeEntry(node)); } break; case SyntaxKind.SourceFile: if (container.kind === SyntaxKind.SourceFile && !isExternalModule(container)) { - result.push(getReferenceEntryFromNode(node)); + result.push(nodeEntry(node)); } break; } @@ -1194,7 +1328,7 @@ namespace ts.FindAllReferences { } } - function getReferencesForStringLiteral(node: StringLiteral, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] { + function getReferencesForStringLiteral(node: StringLiteral, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): SymbolAndEntries[] { const type = getStringLiteralTypeForNode(node, checker); if (!type) { @@ -1202,7 +1336,7 @@ namespace ts.FindAllReferences { return undefined; } - const references: ReferenceEntry[] = []; + const references: NodeEntry[] = []; for (const sourceFile of sourceFiles) { const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, type.text, sourceFile.getStart(), sourceFile.getEnd(), cancellationToken); @@ -1210,19 +1344,11 @@ namespace ts.FindAllReferences { } return [{ - definition: { - containerKind: "", - containerName: "", - fileName: node.getSourceFile().fileName, - kind: ScriptElementKind.variableElement, - name: type.text, - textSpan: createTextSpanFromNode(node), - displayParts: [displayPart(getTextOfNode(node), SymbolDisplayPartKind.stringLiteral)] - }, - references: references + definition: { type: "string", node }, + references }]; - function getReferencesForStringLiteralInFile(sourceFile: SourceFile, searchType: Type, possiblePositions: number[], references: ReferenceEntry[]): void { + function getReferencesForStringLiteralInFile(sourceFile: SourceFile, searchType: Type, possiblePositions: number[], references: Push): void { for (const position of possiblePositions) { cancellationToken.throwIfCancellationRequested(); @@ -1233,7 +1359,7 @@ namespace ts.FindAllReferences { const type = getStringLiteralTypeForNode(node, checker); if (type === searchType) { - references.push(getReferenceEntryFromNode(node)); + references.push(nodeEntry(node, /*isInString*/true)); } } } @@ -1537,7 +1663,7 @@ namespace ts.FindAllReferences { } } - function getReferenceEntriesForShorthandPropertyAssignment(node: Node, checker: TypeChecker, addReference: (node: Node) => void): void { + export function getReferenceEntriesForShorthandPropertyAssignment(node: Node, checker: TypeChecker, addReference: (node: Node) => void): void { const refSymbol = checker.getSymbolAtLocation(node); const shorthandSymbol = checker.getShorthandAssignmentValueSymbol(refSymbol.valueDeclaration); @@ -1550,45 +1676,6 @@ namespace ts.FindAllReferences { } } - function getReferenceEntryFromNode(node: Node): ReferenceEntry { - return { - fileName: node.getSourceFile().fileName, - textSpan: getTextSpan(node), - isWriteAccess: isWriteAccess(node), - isDefinition: isDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node) - }; - } - - function getTextSpan(node: Node): TextSpan { - let start = node.getStart(); - let end = node.getEnd(); - if (node.kind === SyntaxKind.StringLiteral) { - start += 1; - end -= 1; - } - return createTextSpanFromBounds(start, end); - } - - /** A node is considered a writeAccess iff it is a name of a declaration or a target of an assignment */ - function isWriteAccess(node: Node): boolean { - if (node.kind === SyntaxKind.Identifier && isDeclarationName(node)) { - return true; - } - - const parent = node.parent; - if (parent) { - if (parent.kind === SyntaxKind.PostfixUnaryExpression || parent.kind === SyntaxKind.PrefixUnaryExpression) { - return true; - } - else if (parent.kind === SyntaxKind.BinaryExpression && (parent).left === node) { - const operator = (parent).operatorToken.kind; - return SyntaxKind.FirstAssignment <= operator && operator <= SyntaxKind.LastAssignment; - } - } - - return false; - } - function forEachDescendantOfKind(node: Node, kind: SyntaxKind, action: (node: Node) => void): void { forEachChild(node, child => { if (child.kind === kind) { @@ -1639,19 +1726,4 @@ namespace ts.FindAllReferences { return getSymbolsForClassAndInterfaceComponents(localParentType); } } - - /** True if the symbol is for an external module, as opposed to a namespace. */ - export function isExternalModuleSymbol(moduleSymbol: Symbol): boolean { - Debug.assert(!!(moduleSymbol.flags & SymbolFlags.Module)); - return moduleSymbol.name.charCodeAt(0) === CharacterCodes.doubleQuote; - } - - /** Returns `true` the first time it encounters a node and `false` afterwards. */ - export function nodeSeenTracker(): (node: T) => boolean { - const seen: Array = []; - return node => { - const id = getNodeId(node); - return !seen[id] && (seen[id] = true); - }; - } } diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts index 154b046dc40..edbc8cf1a19 100644 --- a/src/services/importTracker.ts +++ b/src/services/importTracker.ts @@ -491,7 +491,7 @@ namespace ts.FindAllReferences { /** If at an export specifier, go to the symbol it refers to. */ function skipExportSpecifierSymbol(symbol: Symbol, checker: TypeChecker): Symbol { // For `export { foo } from './bar", there's nothing to skip, because it does not create a new alias. But `export { foo } does. - for (const declaration of symbol.declarations) { + if (symbol.declarations) for (const declaration of symbol.declarations) { if (isExportSpecifier(declaration) && !(declaration as ExportSpecifier).propertyName && !(declaration as ExportSpecifier).parent.parent.moduleSpecifier) { return checker.getExportSpecifierLocalTargetSymbol(declaration); } diff --git a/src/services/types.ts b/src/services/types.ts index 856b03330bf..4af86a72248 100644 --- a/src/services/types.ts +++ b/src/services/types.ts @@ -479,6 +479,7 @@ namespace ts { displayParts: SymbolDisplayPart[]; } + //!!! internal implementation details leaked!!! export interface ReferencedSymbolOf { definition: ReferencedSymbolDefinitionInfo; references: T[]; diff --git a/src/services/utilities.ts b/src/services/utilities.ts index 385811a55f3..95de9d3a503 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -1132,6 +1132,21 @@ namespace ts { return false; } } + + /** True if the symbol is for an external module, as opposed to a namespace. */ + export function isExternalModuleSymbol(moduleSymbol: Symbol): boolean { + Debug.assert(!!(moduleSymbol.flags & SymbolFlags.Module)); + return moduleSymbol.name.charCodeAt(0) === CharacterCodes.doubleQuote; + } + + /** Returns `true` the first time it encounters a node and `false` afterwards. */ + export function nodeSeenTracker(): (node: T) => boolean { + const seen: Array = []; + return node => { + const id = getNodeId(node); + return !seen[id] && (seen[id] = true); + }; + } } // Display-part writer helpers From 03e0238ceed2aaa4ca818ddbc3ebb27b25bb4f3e Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Fri, 17 Mar 2017 11:54:18 -0700 Subject: [PATCH 07/35] Don't need isInString to be a property --- src/services/findAllReferences.ts | 30 +++++++++++++----------------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index d5d118f0b75..91fa3d5efca 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -8,25 +8,21 @@ namespace ts.FindAllReferences { } type Definition = - | { type: "symbol"; symbol: Symbol; node: Node; } - | { type: "label"; node: Identifier; } - | { type: "keyword"; node: ts.Node; } - | { type: "this"; node: ts.Node; } + | { type: "symbol"; symbol: Symbol; node: Node } + | { type: "label"; node: Identifier } + | { type: "keyword"; node: ts.Node } + | { type: "this"; node: ts.Node } | { type: "string"; node: ts.StringLiteral }; export type Entry = NodeEntry | SpanEntry; - export interface NodeEntry { - type: "node"; - node: Node; - isInString: boolean; - } + export interface NodeEntry { type: "node"; node: Node; } interface SpanEntry { type: "span"; fileName: string; textSpan: TextSpan; } - export function nodeEntry(node: ts.Node, isInString = false): NodeEntry { - return { type: "node", node, isInString }; + export function nodeEntry(node: ts.Node): NodeEntry { + return { type: "node", node }; } export interface Options { @@ -167,13 +163,13 @@ namespace ts.FindAllReferences { return { textSpan: entry.textSpan, fileName: entry.fileName, isWriteAccess: false, isDefinition: false }; } - const { node, isInString } = entry; + const { node } = entry; return { fileName: node.getSourceFile().fileName, textSpan: getTextSpan(node), isWriteAccess: isWriteAccess(node), isDefinition: isDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node), - isInString: isInString ? true : undefined + isInString: node.kind === ts.SyntaxKind.StringLiteral ? true : undefined }; } @@ -215,13 +211,13 @@ namespace ts.FindAllReferences { return { fileName, span: { textSpan, kind: HighlightSpanKind.reference } }; } - const { node, isInString } = entry; + const { node } = entry; const fileName = entry.node.getSourceFile().fileName; const writeAccess = isWriteAccess(node); const span: HighlightSpan = { textSpan: getTextSpan(node), kind: writeAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference, - isInString: isInString ? true : undefined + isInString: node.kind === ts.SyntaxKind.StringLiteral ? true : undefined }; return { fileName, span }; } @@ -483,7 +479,7 @@ namespace ts.FindAllReferences.Core { references = symbolIdToReferences[symbolId] = []; result.push({ definition: { type: "symbol", symbol: referenceSymbol, node: searchLocation }, references }); } - return node => references.push({ type: "node", node, isInString: false }); + return node => references.push(nodeEntry(node)); } function addStringOrCommentReference(fileName: string, textSpan: TextSpan): void { @@ -1359,7 +1355,7 @@ namespace ts.FindAllReferences.Core { const type = getStringLiteralTypeForNode(node, checker); if (type === searchType) { - references.push(nodeEntry(node, /*isInString*/true)); + references.push(nodeEntry(node)); } } } From 4c71862388673c1a048078bfebc90428c99325d4 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Fri, 17 Mar 2017 12:57:34 -0700 Subject: [PATCH 08/35] Nope, need 'isInString' --- src/services/findAllReferences.ts | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index 91fa3d5efca..ba7a6917631 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -15,14 +15,18 @@ namespace ts.FindAllReferences { | { type: "string"; node: ts.StringLiteral }; export type Entry = NodeEntry | SpanEntry; - export interface NodeEntry { type: "node"; node: Node; } + export interface NodeEntry { + type: "node"; + node: Node; + isInString?: true; + } interface SpanEntry { type: "span"; fileName: string; textSpan: TextSpan; } - export function nodeEntry(node: ts.Node): NodeEntry { - return { type: "node", node }; + export function nodeEntry(node: ts.Node, isInString?: true): NodeEntry { + return { type: "node", node, isInString }; } export interface Options { @@ -163,13 +167,13 @@ namespace ts.FindAllReferences { return { textSpan: entry.textSpan, fileName: entry.fileName, isWriteAccess: false, isDefinition: false }; } - const { node } = entry; + const { node, isInString } = entry; return { fileName: node.getSourceFile().fileName, textSpan: getTextSpan(node), isWriteAccess: isWriteAccess(node), isDefinition: isDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node), - isInString: node.kind === ts.SyntaxKind.StringLiteral ? true : undefined + isInString }; } @@ -211,13 +215,13 @@ namespace ts.FindAllReferences { return { fileName, span: { textSpan, kind: HighlightSpanKind.reference } }; } - const { node } = entry; + const { node, isInString } = entry; const fileName = entry.node.getSourceFile().fileName; const writeAccess = isWriteAccess(node); const span: HighlightSpan = { textSpan: getTextSpan(node), kind: writeAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference, - isInString: node.kind === ts.SyntaxKind.StringLiteral ? true : undefined + isInString }; return { fileName, span }; } @@ -1355,7 +1359,7 @@ namespace ts.FindAllReferences.Core { const type = getStringLiteralTypeForNode(node, checker); if (type === searchType) { - references.push(nodeEntry(node)); + references.push(nodeEntry(node, /*isInString*/true)); } } } From 5bcb8fa9fa33f73bd62bc09b2e561c84e42905ee Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Tue, 21 Mar 2017 13:24:39 -0700 Subject: [PATCH 09/35] Don't need types to handle string literals --- src/services/findAllReferences.ts | 27 +++++++-------------------- src/services/rename.ts | 13 +++++-------- src/services/utilities.ts | 9 --------- 3 files changed, 12 insertions(+), 37 deletions(-) diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index ba7a6917631..a40af45a25c 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -279,7 +279,7 @@ namespace ts.FindAllReferences.Core { if (!symbol) { // String literal might be a property (and thus have a symbol), so do this here rather than in getReferencedSymbolsSpecial. if (!options.implementations && node.kind === SyntaxKind.StringLiteral) { - return getReferencesForStringLiteral(node, sourceFiles, checker, cancellationToken); + return getReferencesForStringLiteral(node, sourceFiles, cancellationToken); } // Can't have references to something that we have no symbol for. return undefined; @@ -1328,19 +1328,13 @@ namespace ts.FindAllReferences.Core { } } - function getReferencesForStringLiteral(node: StringLiteral, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): SymbolAndEntries[] { - const type = getStringLiteralTypeForNode(node, checker); - - if (!type) { - // nothing to do here. moving on - return undefined; - } - + function getReferencesForStringLiteral(node: StringLiteral, sourceFiles: SourceFile[], cancellationToken: CancellationToken): SymbolAndEntries[] { const references: NodeEntry[] = []; for (const sourceFile of sourceFiles) { - const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, type.text, sourceFile.getStart(), sourceFile.getEnd(), cancellationToken); - getReferencesForStringLiteralInFile(sourceFile, type, possiblePositions, references); + cancellationToken.throwIfCancellationRequested(); + const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, node.text, sourceFile.getStart(), sourceFile.getEnd(), cancellationToken); + getReferencesForStringLiteralInFile(sourceFile, node.text, possiblePositions, references); } return [{ @@ -1348,17 +1342,10 @@ namespace ts.FindAllReferences.Core { references }]; - function getReferencesForStringLiteralInFile(sourceFile: SourceFile, searchType: Type, possiblePositions: number[], references: Push): void { + function getReferencesForStringLiteralInFile(sourceFile: SourceFile, searchText: string, possiblePositions: number[], references: Push): void { for (const position of possiblePositions) { - cancellationToken.throwIfCancellationRequested(); - const node = getTouchingWord(sourceFile, position); - if (!node || node.kind !== SyntaxKind.StringLiteral) { - return; - } - - const type = getStringLiteralTypeForNode(node, checker); - if (type === searchType) { + if (node && node.kind === SyntaxKind.StringLiteral && (node as StringLiteral).text === searchText) { references.push(nodeEntry(node, /*isInString*/true)); } } diff --git a/src/services/rename.ts b/src/services/rename.ts index 556283a44f4..bee530340bd 100644 --- a/src/services/rename.ts +++ b/src/services/rename.ts @@ -37,15 +37,12 @@ namespace ts.Rename { } } else if (node.kind === SyntaxKind.StringLiteral) { - const type = getStringLiteralTypeForNode(node, typeChecker); - if (type) { - if (isDefinedInLibraryFile(node)) { - return getRenameInfoError(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library); - } - - const displayName = stripQuotes(type.text); - return getRenameInfoSuccess(displayName, displayName, ScriptElementKind.variableElement, ScriptElementKindModifier.none, node, sourceFile); + if (isDefinedInLibraryFile(node)) { + return getRenameInfoError(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library); } + + const displayName = stripQuotes((node as StringLiteral).text); + return getRenameInfoSuccess(displayName, displayName, ScriptElementKind.variableElement, ScriptElementKindModifier.none, node, sourceFile); } } diff --git a/src/services/utilities.ts b/src/services/utilities.ts index 95de9d3a503..9996c3cb160 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -364,15 +364,6 @@ namespace ts { } } - export function getStringLiteralTypeForNode(node: StringLiteral | LiteralTypeNode, typeChecker: TypeChecker): LiteralType { - const searchNode = node.parent.kind === SyntaxKind.LiteralType ? node.parent : node; - const type = typeChecker.getTypeAtLocation(searchNode); - if (type && type.flags & TypeFlags.StringLiteral) { - return type; - } - return undefined; - } - export function isThis(node: Node): boolean { switch (node.kind) { case SyntaxKind.ThisKeyword: From 19ada9719a6a747435b6e644c42716a76510c0c3 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Thu, 23 Mar 2017 10:26:05 -0700 Subject: [PATCH 10/35] Fix #14620: Lookup names in exports as well as locals when binding special properties --- src/compiler/binder.ts | 8 +- ...gClassStaticMembersFromAssignments.symbols | 131 +++++++++++++++ ...ingClassStaticMembersFromAssignments.types | 151 ++++++++++++++++++ ...erringClassStaticMembersFromAssignments.ts | 43 +++++ 4 files changed, 331 insertions(+), 2 deletions(-) create mode 100644 tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols create mode 100644 tests/baselines/reference/inferringClassStaticMembersFromAssignments.types create mode 100644 tests/cases/conformance/salsa/inferringClassStaticMembersFromAssignments.ts diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 650797c6dba..6438d803a1f 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -2297,7 +2297,7 @@ namespace ts { function isNameOfExportsOrModuleExportsAliasDeclaration(node: Node) { if (node.kind === SyntaxKind.Identifier) { - const symbol = container.locals.get((node).text); + const symbol = lookupSymbolForName((node).text); if (symbol && symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.VariableDeclaration) { const declaration = symbol.valueDeclaration as VariableDeclaration; if (declaration.initializer) { @@ -2399,8 +2399,12 @@ namespace ts { } } + function lookupSymbolForName(name: string) { + return (container.symbol && container.symbol.exports && container.symbol.exports.get(name)) || container.locals.get(name); + } + function bindPropertyAssignment(functionName: string, propertyAccessExpression: PropertyAccessExpression, isPrototypeProperty: boolean) { - let targetSymbol = container.locals.get(functionName); + let targetSymbol = lookupSymbolForName(functionName); if (targetSymbol && isDeclarationOfFunctionOrClassExpression(targetSymbol)) { targetSymbol = (targetSymbol.valueDeclaration as VariableDeclaration).initializer.symbol; diff --git a/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols new file mode 100644 index 00000000000..85f8e2a83e6 --- /dev/null +++ b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols @@ -0,0 +1,131 @@ +=== tests/cases/conformance/salsa/a.js === + +export class C1 { } +>C1 : Symbol(C1, Decl(a.js, 0, 0)) + +C1.staticProp = 0; +>C1.staticProp : Symbol(C1.staticProp, Decl(a.js, 1, 19)) +>C1 : Symbol(C1, Decl(a.js, 0, 0)) +>staticProp : Symbol(C1.staticProp, Decl(a.js, 1, 19)) + +export function F1() { } +>F1 : Symbol(F1, Decl(a.js, 2, 18)) + +F1.staticProp = 0; +>F1.staticProp : Symbol(F1.staticProp, Decl(a.js, 4, 24)) +>F1 : Symbol(F1, Decl(a.js, 2, 18)) +>staticProp : Symbol(F1.staticProp, Decl(a.js, 4, 24)) + +export var C2 = class { }; +>C2 : Symbol(C2, Decl(a.js, 7, 10)) + +C2.staticProp = 0; +>C2.staticProp : Symbol(C2.staticProp, Decl(a.js, 7, 26)) +>C2 : Symbol(C2, Decl(a.js, 7, 10)) +>staticProp : Symbol(C2.staticProp, Decl(a.js, 7, 26)) + +export let F2 = function () { }; +>F2 : Symbol(F2, Decl(a.js, 10, 10)) + +F2.staticProp = 0; +>F2.staticProp : Symbol(F2.staticProp, Decl(a.js, 10, 32)) +>F2 : Symbol(F2, Decl(a.js, 10, 10)) +>staticProp : Symbol(F2.staticProp, Decl(a.js, 10, 32)) + +=== tests/cases/conformance/salsa/global.js === +class C3 { } +>C3 : Symbol(C3, Decl(global.js, 0, 0)) + +C3.staticProp = 0; +>C3.staticProp : Symbol(C3.staticProp, Decl(global.js, 0, 12)) +>C3 : Symbol(C3, Decl(global.js, 0, 0)) +>staticProp : Symbol(C3.staticProp, Decl(global.js, 0, 12)) + +function F3() { } +>F3 : Symbol(F3, Decl(global.js, 1, 18)) + +F3.staticProp = 0; +>F3.staticProp : Symbol(F3.staticProp, Decl(global.js, 3, 17)) +>F3 : Symbol(F3, Decl(global.js, 1, 18)) +>staticProp : Symbol(F3.staticProp, Decl(global.js, 3, 17)) + +var C4 = class { }; +>C4 : Symbol(C4, Decl(global.js, 6, 3)) + +C4.staticProp = 0; +>C4.staticProp : Symbol(C4.staticProp, Decl(global.js, 6, 19)) +>C4 : Symbol(C4, Decl(global.js, 6, 3)) +>staticProp : Symbol(C4.staticProp, Decl(global.js, 6, 19)) + +let F4 = function () { }; +>F4 : Symbol(F4, Decl(global.js, 9, 3)) + +F4.staticProp = 0; +>F4.staticProp : Symbol(F4.staticProp, Decl(global.js, 9, 25)) +>F4 : Symbol(F4, Decl(global.js, 9, 3)) +>staticProp : Symbol(F4.staticProp, Decl(global.js, 9, 25)) + +=== tests/cases/conformance/salsa/b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +var n: number; +>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) + +var n = a.C1.staticProp; +>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) +>a.C1.staticProp : Symbol(a.C1.staticProp, Decl(a.js, 1, 19)) +>a.C1 : Symbol(a.C1, Decl(a.js, 0, 0)) +>a : Symbol(a, Decl(b.ts, 0, 6)) +>C1 : Symbol(a.C1, Decl(a.js, 0, 0)) +>staticProp : Symbol(a.C1.staticProp, Decl(a.js, 1, 19)) + +var n = a.C2.staticProp; +>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) +>a.C2.staticProp : Symbol(C2.staticProp, Decl(a.js, 7, 26)) +>a.C2 : Symbol(a.C2, Decl(a.js, 7, 10)) +>a : Symbol(a, Decl(b.ts, 0, 6)) +>C2 : Symbol(a.C2, Decl(a.js, 7, 10)) +>staticProp : Symbol(C2.staticProp, Decl(a.js, 7, 26)) + +var n = a.F1.staticProp; +>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) +>a.F1.staticProp : Symbol(a.F1.staticProp, Decl(a.js, 4, 24)) +>a.F1 : Symbol(a.F1, Decl(a.js, 2, 18)) +>a : Symbol(a, Decl(b.ts, 0, 6)) +>F1 : Symbol(a.F1, Decl(a.js, 2, 18)) +>staticProp : Symbol(a.F1.staticProp, Decl(a.js, 4, 24)) + +var n = a.F2.staticProp; +>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) +>a.F2.staticProp : Symbol(F2.staticProp, Decl(a.js, 10, 32)) +>a.F2 : Symbol(a.F2, Decl(a.js, 10, 10)) +>a : Symbol(a, Decl(b.ts, 0, 6)) +>F2 : Symbol(a.F2, Decl(a.js, 10, 10)) +>staticProp : Symbol(F2.staticProp, Decl(a.js, 10, 32)) + + +var n = C3.staticProp; +>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) +>C3.staticProp : Symbol(C3.staticProp, Decl(global.js, 0, 12)) +>C3 : Symbol(C3, Decl(global.js, 0, 0)) +>staticProp : Symbol(C3.staticProp, Decl(global.js, 0, 12)) + +var n = C4.staticProp; +>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) +>C4.staticProp : Symbol(C4.staticProp, Decl(global.js, 6, 19)) +>C4 : Symbol(C4, Decl(global.js, 6, 3)) +>staticProp : Symbol(C4.staticProp, Decl(global.js, 6, 19)) + +var n = F3.staticProp; +>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) +>F3.staticProp : Symbol(F3.staticProp, Decl(global.js, 3, 17)) +>F3 : Symbol(F3, Decl(global.js, 1, 18)) +>staticProp : Symbol(F3.staticProp, Decl(global.js, 3, 17)) + +var n = F4.staticProp; +>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) +>F4.staticProp : Symbol(F4.staticProp, Decl(global.js, 9, 25)) +>F4 : Symbol(F4, Decl(global.js, 9, 3)) +>staticProp : Symbol(F4.staticProp, Decl(global.js, 9, 25)) + diff --git a/tests/baselines/reference/inferringClassStaticMembersFromAssignments.types b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.types new file mode 100644 index 00000000000..d5a70d1fd80 --- /dev/null +++ b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.types @@ -0,0 +1,151 @@ +=== tests/cases/conformance/salsa/a.js === + +export class C1 { } +>C1 : C1 + +C1.staticProp = 0; +>C1.staticProp = 0 : 0 +>C1.staticProp : number +>C1 : typeof C1 +>staticProp : number +>0 : 0 + +export function F1() { } +>F1 : { (): void; staticProp: number; } + +F1.staticProp = 0; +>F1.staticProp = 0 : 0 +>F1.staticProp : number +>F1 : { (): void; staticProp: number; } +>staticProp : number +>0 : 0 + +export var C2 = class { }; +>C2 : typeof C2 +>class { } : typeof C2 + +C2.staticProp = 0; +>C2.staticProp = 0 : 0 +>C2.staticProp : number +>C2 : typeof C2 +>staticProp : number +>0 : 0 + +export let F2 = function () { }; +>F2 : { (): void; staticProp: number; } +>function () { } : { (): void; staticProp: number; } + +F2.staticProp = 0; +>F2.staticProp = 0 : 0 +>F2.staticProp : number +>F2 : { (): void; staticProp: number; } +>staticProp : number +>0 : 0 + +=== tests/cases/conformance/salsa/global.js === +class C3 { } +>C3 : C3 + +C3.staticProp = 0; +>C3.staticProp = 0 : 0 +>C3.staticProp : number +>C3 : typeof C3 +>staticProp : number +>0 : 0 + +function F3() { } +>F3 : { (): void; staticProp: number; } + +F3.staticProp = 0; +>F3.staticProp = 0 : 0 +>F3.staticProp : number +>F3 : { (): void; staticProp: number; } +>staticProp : number +>0 : 0 + +var C4 = class { }; +>C4 : typeof C4 +>class { } : typeof C4 + +C4.staticProp = 0; +>C4.staticProp = 0 : 0 +>C4.staticProp : number +>C4 : typeof C4 +>staticProp : number +>0 : 0 + +let F4 = function () { }; +>F4 : { (): void; staticProp: number; } +>function () { } : { (): void; staticProp: number; } + +F4.staticProp = 0; +>F4.staticProp = 0 : 0 +>F4.staticProp : number +>F4 : { (): void; staticProp: number; } +>staticProp : number +>0 : 0 + +=== tests/cases/conformance/salsa/b.ts === +import * as a from "./a"; +>a : typeof a + +var n: number; +>n : number + +var n = a.C1.staticProp; +>n : number +>a.C1.staticProp : number +>a.C1 : typeof a.C1 +>a : typeof a +>C1 : typeof a.C1 +>staticProp : number + +var n = a.C2.staticProp; +>n : number +>a.C2.staticProp : number +>a.C2 : typeof C2 +>a : typeof a +>C2 : typeof C2 +>staticProp : number + +var n = a.F1.staticProp; +>n : number +>a.F1.staticProp : number +>a.F1 : { (): void; staticProp: number; } +>a : typeof a +>F1 : { (): void; staticProp: number; } +>staticProp : number + +var n = a.F2.staticProp; +>n : number +>a.F2.staticProp : number +>a.F2 : { (): void; staticProp: number; } +>a : typeof a +>F2 : { (): void; staticProp: number; } +>staticProp : number + + +var n = C3.staticProp; +>n : number +>C3.staticProp : number +>C3 : typeof C3 +>staticProp : number + +var n = C4.staticProp; +>n : number +>C4.staticProp : number +>C4 : typeof C4 +>staticProp : number + +var n = F3.staticProp; +>n : number +>F3.staticProp : number +>F3 : { (): void; staticProp: number; } +>staticProp : number + +var n = F4.staticProp; +>n : number +>F4.staticProp : number +>F4 : { (): void; staticProp: number; } +>staticProp : number + diff --git a/tests/cases/conformance/salsa/inferringClassStaticMembersFromAssignments.ts b/tests/cases/conformance/salsa/inferringClassStaticMembersFromAssignments.ts new file mode 100644 index 00000000000..7ed3a81dcfe --- /dev/null +++ b/tests/cases/conformance/salsa/inferringClassStaticMembersFromAssignments.ts @@ -0,0 +1,43 @@ +// @noEmit: true +// @allowJs: true + +// @filename: a.js +export class C1 { } +C1.staticProp = 0; + +export function F1() { } +F1.staticProp = 0; + +export var C2 = class { }; +C2.staticProp = 0; + +export let F2 = function () { }; +F2.staticProp = 0; + +//@filename: global.js +class C3 { } +C3.staticProp = 0; + +function F3() { } +F3.staticProp = 0; + +var C4 = class { }; +C4.staticProp = 0; + +let F4 = function () { }; +F4.staticProp = 0; + +// @filename: b.ts +import * as a from "./a"; +var n: number; + +var n = a.C1.staticProp; +var n = a.C2.staticProp; +var n = a.F1.staticProp; +var n = a.F2.staticProp; + + +var n = C3.staticProp; +var n = C4.staticProp; +var n = F3.staticProp; +var n = F4.staticProp; \ No newline at end of file From 7739a88926281ba2e300d81a6c741f25587e8759 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Mon, 27 Mar 2017 10:57:54 -0700 Subject: [PATCH 11/35] getReferencesInContainer: Take sourceFile as parameter --- src/services/findAllReferences.ts | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index a40af45a25c..ee37e07de82 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -339,7 +339,7 @@ namespace ts.FindAllReferences.Core { // otherwise we'll need to search globally (i.e. include each file). const scope = getSymbolScope(symbol); if (scope) { - getReferencesInContainer(scope, search, state); + getReferencesInContainer(scope, scope.getSourceFile(), search, state); } else { // Global search @@ -516,7 +516,7 @@ namespace ts.FindAllReferences.Core { // For each import, find all references to that import in its source file. for (const [importLocation, importSymbol] of importSearches) { state.cancellationToken.throwIfCancellationRequested(); - getReferencesInContainer(importLocation.getSourceFile(), state.createSearch(importLocation, importSymbol, ImportExport.Export), state); + getReferencesInSourceFile(importLocation.getSourceFile(), state.createSearch(importLocation, importSymbol, ImportExport.Export), state); } if (indirectUsers.length) { @@ -543,14 +543,14 @@ namespace ts.FindAllReferences.Core { // Go to the symbol we imported from and find references for it. function searchForImportedSymbol(symbol: Symbol, state: State): void { for (const declaration of symbol.declarations) { - getReferencesInContainer(declaration.getSourceFile(), state.createSearch(declaration, symbol, ImportExport.Import), state); + getReferencesInSourceFile(declaration.getSourceFile(), state.createSearch(declaration, symbol, ImportExport.Import), state); } } /** Search for all occurences of an identifier in a source file (and filter out the ones that match). */ function searchForName(sourceFile: SourceFile, search: Search, state: State): void { if (sourceFileHasName(sourceFile, search.escapedText)) { - getReferencesInContainer(sourceFile, search, state); + getReferencesInSourceFile(sourceFile, search, state); } } @@ -748,13 +748,16 @@ namespace ts.FindAllReferences.Core { } } + function getReferencesInSourceFile(sourceFile: ts.SourceFile, search: Search, state: State): void { + return getReferencesInContainer(sourceFile, sourceFile, search, state); + } + /** * Search within node "container" for references for a search value, where the search value is defined as a * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning). * searchLocation: a node where the search value */ - function getReferencesInContainer(container: Node, search: Search, state: State): void { - const sourceFile = container.getSourceFile(); + function getReferencesInContainer(container: Node, sourceFile: ts.SourceFile, search: Search, state: State): void { if (!state.markSearchedSymbol(sourceFile, search.symbol)) { return; } From cf6c24cd02e2ac37e53f69d4d558a22811520795 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Mon, 27 Mar 2017 11:46:38 -0700 Subject: [PATCH 12/35] Respond to minor PR comments --- src/services/findAllReferences.ts | 33 +++++++++---------- src/services/importTracker.ts | 25 +++++++------- src/services/rename.ts | 14 +++++--- ...indAllRefsDefaultImportThroughNamespace.ts | 12 +++++-- 4 files changed, 48 insertions(+), 36 deletions(-) diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index a0c93a4b53d..581774ae219 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -520,17 +520,18 @@ namespace ts.FindAllReferences.Core { } if (indirectUsers.length) { - const indirectSearch = (() => { - switch (exportInfo.exportKind) { - case ExportKind.Named: - return state.createSearch(exportLocation, exportSymbol, ImportExport.Export); - case ExportKind.Default: - // Search for a property access to '.default'. This can't be renamed. - return state.isForRename ? undefined : state.createSearch(exportLocation, exportSymbol, ImportExport.Export, { text: "default" }); - case ExportKind.ExportEquals: - return undefined; - } - })(); + let indirectSearch: Search | undefined; + switch (exportInfo.exportKind) { + case ExportKind.Named: + indirectSearch = state.createSearch(exportLocation, exportSymbol, ImportExport.Export); + break; + case ExportKind.Default: + // Search for a property access to '.default'. This can't be renamed. + indirectSearch = state.isForRename ? undefined : state.createSearch(exportLocation, exportSymbol, ImportExport.Export, { text: "default" }); + break; + case ExportKind.ExportEquals: + break; + } if (indirectSearch) { for (const indirectUser of indirectUsers) { state.cancellationToken.throwIfCancellationRequested(); @@ -549,15 +550,11 @@ namespace ts.FindAllReferences.Core { /** Search for all occurences of an identifier in a source file (and filter out the ones that match). */ function searchForName(sourceFile: SourceFile, search: Search, state: State): void { - if (sourceFileHasName(sourceFile, search.escapedText)) { + if (getNameTable(sourceFile).get(search.escapedText) !== undefined) { getReferencesInSourceFile(sourceFile, search, state); } } - function sourceFileHasName(sourceFile: SourceFile, escapedName: string): boolean { - return getNameTable(sourceFile).get(escapedName) !== undefined; - } - function getPropertySymbolOfDestructuringAssignment(location: Node, checker: TypeChecker): Symbol | undefined { return isArrayLiteralOrObjectLiteralDestructuringPattern(location.parent.parent) && checker.getPropertySymbolOfDestructuringAssignment(location); @@ -613,7 +610,9 @@ namespace ts.FindAllReferences.Core { return undefined; } - // The only symbols with parents *not* globally acessible are exports of external modules, and only then if they do not have `export as namespace`. + // If the symbol has a parent, it's globally visible. + // Unless that parent is an external module, then we should only search in the module (and recurse on the export later). + // But if the parent is a module that has `export as namespace`, then the symbol *is* globally visible. if (parent && !((parent.flags & SymbolFlags.Module) && isExternalModuleSymbol(parent) && !parent.globalExports)) { return undefined; } diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts index edbc8cf1a19..d9fe2cd19d3 100644 --- a/src/services/importTracker.ts +++ b/src/services/importTracker.ts @@ -36,7 +36,7 @@ namespace ts.FindAllReferences { type ImporterOrCallExpression = Importer | CallExpression; /** Returns import statements that directly reference the exporting module, and a list of files that may access the module through a namespace. */ - function getImportersForExport(sourceFiles: SourceFile[], allDirectImports: ImporterOrCallExpression[][], { exportingModuleSymbol, exportKind }: ExportInfo, checker: TypeChecker): { directImports: Importer[], indirectUsers: SourceFile[] } { + function getImportersForExport(sourceFiles: SourceFile[], allDirectImports: Map, { exportingModuleSymbol, exportKind }: ExportInfo, checker: TypeChecker): { directImports: Importer[], indirectUsers: SourceFile[] } { const markSeenDirectImport = nodeSeenTracker(); const markSeenIndirectUser = nodeSeenTracker(); const directImports: Importer[] = []; @@ -148,7 +148,7 @@ namespace ts.FindAllReferences { } function getDirectImports(moduleSymbol: Symbol): ImporterOrCallExpression[] | undefined { - return allDirectImports[getSymbolId(moduleSymbol)]; + return allDirectImports.get(getSymbolId(moduleSymbol).toString()); } } @@ -173,7 +173,7 @@ namespace ts.FindAllReferences { function handleImport(decl: Importer): void { if (decl.kind === SyntaxKind.ImportEqualsDeclaration) { - if (isProperImportEquals(decl)) { + if (isExternalModuleImportEquals(decl)) { handleNamespaceImportLike(decl.name); } return; @@ -274,17 +274,17 @@ namespace ts.FindAllReferences { } /** Returns a map from a module symbol Id to all import statements that directly reference the module. */ - function getDirectImportsMap(sourceFiles: SourceFile[], checker: TypeChecker): ImporterOrCallExpression[][] { - const map: ImporterOrCallExpression[][] = []; + function getDirectImportsMap(sourceFiles: SourceFile[], checker: TypeChecker): Map { + const map = createMap(); for (const sourceFile of sourceFiles) { forEachImport(sourceFile, (importDecl, moduleSpecifier) => { const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier); if (moduleSymbol) { - const id = getSymbolId(moduleSymbol); - let imports = map[id]; + const id = getSymbolId(moduleSymbol).toString(); + let imports = map.get(id); if (!imports) { - imports = map[id] = []; + map.set(id, imports = []); } imports.push(importDecl); } @@ -371,8 +371,7 @@ namespace ts.FindAllReferences { * @param comingFromExport If we are doing a search for all exports, don't bother looking backwards for the imported symbol, since that's the reason we're here. */ export function getImportOrExportSymbol(node: Node, symbol: Symbol, checker: TypeChecker, comingFromExport: boolean): ImportedSymbol | ExportedSymbol | undefined { - const ex = getExport(); - return ex || comingFromExport ? ex : getImport(); + return comingFromExport ? getExport() : getExport() || getImport(); function getExport(): ExportedSymbol | ImportedSymbol | undefined { const { parent } = node; @@ -459,7 +458,9 @@ namespace ts.FindAllReferences { const { parent } = node; switch (parent.kind) { case SyntaxKind.ImportEqualsDeclaration: - return (parent as ImportEqualsDeclaration).name === node ? { isNamedImport: false } : undefined; + return (parent as ImportEqualsDeclaration).name === node && isExternalModuleImportEquals(parent as ImportEqualsDeclaration) + ? { isNamedImport: false } + : undefined; case SyntaxKind.ImportSpecifier: // For a rename import `{ foo as bar }`, don't search for the imported symbol. Just find local uses of `bar`. return (parent as ImportSpecifier).propertyName ? undefined : { isNamedImport: true }; @@ -522,7 +523,7 @@ namespace ts.FindAllReferences { return node.kind === SyntaxKind.ModuleDeclaration && (node as ModuleDeclaration).name.kind === SyntaxKind.StringLiteral; } - function isProperImportEquals({ moduleReference }: ImportEqualsDeclaration): boolean { + function isExternalModuleImportEquals({ moduleReference }: ImportEqualsDeclaration): boolean { return moduleReference.kind === SyntaxKind.ExternalModuleReference && moduleReference.expression.kind === SyntaxKind.StringLiteral } } diff --git a/src/services/rename.ts b/src/services/rename.ts index bee530340bd..27c47179052 100644 --- a/src/services/rename.ts +++ b/src/services/rename.ts @@ -31,6 +31,13 @@ namespace ts.Rename { return getRenameInfoError(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library); } + // Cannot rename `default` as in `import { default as foo } from "./someModule"; + if (node.kind === SyntaxKind.Identifier && + (node as Identifier).originalKeywordKind === SyntaxKind.DefaultKeyword && + symbol.parent.flags & ts.SymbolFlags.Module) { + return undefined; + } + const displayName = stripQuotes(getDeclaredName(typeChecker, symbol, node)); const kind = SymbolDisplay.getSymbolKind(typeChecker, symbol, node); return kind ? getRenameInfoSuccess(displayName, typeChecker.getFullyQualifiedName(symbol), kind, SymbolDisplay.getSymbolModifiers(symbol), node, sourceFile) : undefined; @@ -82,11 +89,8 @@ namespace ts.Rename { } function nodeIsEligibleForRename(node: Node): boolean { - if (node.kind === SyntaxKind.Identifier) { - // Cannot rename `default` as in `import { default as foo } from "./someModule"; - return (node as Identifier).originalKeywordKind !== SyntaxKind.DefaultKeyword; - } - return node.kind === SyntaxKind.StringLiteral || + return node.kind === ts.SyntaxKind.Identifier || + node.kind === SyntaxKind.StringLiteral || isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || isThis(node); } diff --git a/tests/cases/fourslash/findAllRefsDefaultImportThroughNamespace.ts b/tests/cases/fourslash/findAllRefsDefaultImportThroughNamespace.ts index b282af52ec1..e5f77631324 100644 --- a/tests/cases/fourslash/findAllRefsDefaultImportThroughNamespace.ts +++ b/tests/cases/fourslash/findAllRefsDefaultImportThroughNamespace.ts @@ -9,12 +9,20 @@ // @Filename: /c.ts ////import { a } from "./b"; ////a.[|default|](); +//// +////declare const x: { [|{| "isWriteAccess": true, "isDefinition": true |}default|]: number }; +////x.[|default|]; -verify.singleReferenceGroup("function f(): void"); +const [r0, r1, r2, r3] = test.ranges(); -const [r0, r1] = test.ranges(); +verify.singleReferenceGroup("function f(): void", [r0, r1]); +verify.singleReferenceGroup("(property) default: number", [r2, r3]); verify.rangesAreRenameLocations([r0]); +// Can't rename a default import. goTo.rangeStart(r1); verify.renameInfoFailed(); + +// Can rename a default property. +verify.rangesAreRenameLocations([r2, r3]); From 2dd23fa0a8131f73f1069c2aad6e403adc3159cc Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Mon, 27 Mar 2017 11:51:13 -0700 Subject: [PATCH 13/35] Lint --- src/harness/fourslash.ts | 4 ++-- src/services/importTracker.ts | 10 +++++----- src/services/types.ts | 8 ++------ 3 files changed, 9 insertions(+), 13 deletions(-) diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index 2f240e4a930..56b4940c835 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -561,7 +561,7 @@ namespace FourSlash { const errors = this.getDiagnostics(fileName); if (errors.length) { this.printErrorLog(/*expectErrors*/ false, errors); - const error = errors[0] + const error = errors[0]; this.raiseError(`Found an error: ${error.file.fileName}@${error.start}: ${error.messageText}`); } }); @@ -1174,7 +1174,7 @@ namespace FourSlash { let findInStrings: boolean, findInComments: boolean, ranges: Range[]; if (ts.isArray(options)) { findInStrings = findInComments = false; - ranges = options + ranges = options; } else { findInStrings = !!options.findInStrings; diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts index d9fe2cd19d3..5bbcdb220fe 100644 --- a/src/services/importTracker.ts +++ b/src/services/importTracker.ts @@ -17,7 +17,7 @@ namespace ts.FindAllReferences { return (exportSymbol, exportInfo, isForRename) => { const { directImports, indirectUsers } = getImportersForExport(sourceFiles, allDirectImports, exportInfo, checker); return { indirectUsers, ...getSearchesFromDirectImports(directImports, exportSymbol, exportInfo.exportKind, checker, isForRename) }; - } + }; } /** Info about an exported symbol to perform recursive search on. */ @@ -86,7 +86,7 @@ namespace ts.FindAllReferences { case SyntaxKind.ImportDeclaration: const namedBindings = direct.importClause && direct.importClause.namedBindings; if (namedBindings && namedBindings.kind === SyntaxKind.NamespaceImport) { - handleNamespaceImport(direct, namedBindings.name) + handleNamespaceImport(direct, namedBindings.name); } else { directImports.push(direct); @@ -418,7 +418,7 @@ namespace ts.FindAllReferences { // Get the symbol for the `export =` node; its parent is the module it's the export of. const exportingModuleSymbol = parent.symbol.parent; Debug.assert(!!exportingModuleSymbol); - return { kind: ImportExport.Export, symbol, exportInfo: { exportingModuleSymbol, exportKind: ExportKind.ExportEquals } } + return { kind: ImportExport.Export, symbol, exportInfo: { exportingModuleSymbol, exportKind: ExportKind.ExportEquals } }; } } } @@ -445,7 +445,7 @@ namespace ts.FindAllReferences { function exportInfo(symbol: Symbol, kind: ExportKind): ExportedSymbol { const exportInfo = getExportInfo(symbol, kind, checker); - return exportInfo && { kind: ImportExport.Export, symbol, exportInfo } + return exportInfo && { kind: ImportExport.Export, symbol, exportInfo }; } // Not meant for use with export specifiers or export assignment. @@ -524,6 +524,6 @@ namespace ts.FindAllReferences { } function isExternalModuleImportEquals({ moduleReference }: ImportEqualsDeclaration): boolean { - return moduleReference.kind === SyntaxKind.ExternalModuleReference && moduleReference.expression.kind === SyntaxKind.StringLiteral + return moduleReference.kind === SyntaxKind.ExternalModuleReference && moduleReference.expression.kind === SyntaxKind.StringLiteral; } } diff --git a/src/services/types.ts b/src/services/types.ts index 19ed0bce254..dafd7b46b33 100644 --- a/src/services/types.ts +++ b/src/services/types.ts @@ -481,13 +481,9 @@ namespace ts { displayParts: SymbolDisplayPart[]; } - //!!! internal implementation details leaked!!! - export interface ReferencedSymbolOf { + export interface ReferencedSymbol { definition: ReferencedSymbolDefinitionInfo; - references: T[]; - } - - export interface ReferencedSymbol extends ReferencedSymbolOf { + references: ReferenceEntry[]; } export enum SymbolDisplayPartKind { From 28a3604714f110eb6680f785b9a4759171a53aa2 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Mon, 27 Mar 2017 13:53:43 -0700 Subject: [PATCH 14/35] Fix #14346 --- src/services/findAllReferences.ts | 6 -- src/services/importTracker.ts | 67 ++++++++++++++++------ tests/cases/fourslash/renameJsExports02.ts | 16 ++++++ tests/cases/fourslash/renameJsExports03.ts | 31 ++++++++++ 4 files changed, 95 insertions(+), 25 deletions(-) create mode 100644 tests/cases/fourslash/renameJsExports02.ts create mode 100644 tests/cases/fourslash/renameJsExports03.ts diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index 581774ae219..d909419def4 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -935,8 +935,6 @@ namespace ts.FindAllReferences.Core { addReference(referenceLocation, search.symbol, search.location, state); } - const classSymbol = skipAliases(search.symbol, state.checker); - Debug.assert(isClassLike(classSymbol.valueDeclaration)); const pusher = state.referenceAdder(search.symbol, search.location); if (isClassLike(referenceLocation.parent)) { @@ -1687,10 +1685,6 @@ namespace ts.FindAllReferences.Core { return false; } - function skipAliases(symbol: Symbol, checker: TypeChecker): Symbol { - return symbol.flags & SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol; - } - /** * If we are just looking for implementations and this is a property access expression, we need to get the * symbol of the local type of the symbol the property is being accessed on. This is because our search diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts index 5bbcdb220fe..b9b0d319844 100644 --- a/src/services/importTracker.ts +++ b/src/services/importTracker.ts @@ -32,7 +32,8 @@ namespace ts.FindAllReferences { interface AmbientModuleDeclaration extends ModuleDeclaration { body?: ModuleBlock; } type SourceFileLike = SourceFile | AmbientModuleDeclaration; - type Importer = AnyImportSyntax | ExportDeclaration; + // Identifier for the case of `const x = require("y")`. + type Importer = AnyImportSyntax | Identifier | ExportDeclaration; type ImporterOrCallExpression = Importer | CallExpression; /** Returns import statements that directly reference the exporting module, and a list of files that may access the module through a namespace. */ @@ -55,7 +56,7 @@ namespace ts.FindAllReferences { // Module augmentations may use this module's exports without importing it. for (const decl of exportingModuleSymbol.declarations) { - if (ts.isExternalModuleAugmentation(decl)) { + if (isExternalModuleAugmentation(decl)) { addIndirectUser(decl as SourceFileLike); } } @@ -74,6 +75,15 @@ namespace ts.FindAllReferences { switch (direct.kind) { case SyntaxKind.CallExpression: if (!isAvailableThroughGlobal) { + const parent = direct.parent!; + if (exportKind === ExportKind.ExportEquals && parent.kind === SyntaxKind.VariableDeclaration) { + const { name } = parent as ts.VariableDeclaration; + if (name.kind === SyntaxKind.Identifier) { + directImports.push(name); + break; + } + } + // Don't support re-exporting 'require()' calls, so just add a single indirect user. addIndirectUser(direct.getSourceFile()); } @@ -179,6 +189,11 @@ namespace ts.FindAllReferences { return; } + if (decl.kind === ts.SyntaxKind.Identifier) { + handleNamespaceImportLike(decl); + return; + } + // Ignore if there's a grammar error if (decl.moduleSpecifier.kind !== SyntaxKind.StringLiteral) { return; @@ -192,7 +207,7 @@ namespace ts.FindAllReferences { const { importClause } = decl; const { namedBindings } = importClause; - if (namedBindings && namedBindings.kind === ts.SyntaxKind.NamespaceImport) { + if (namedBindings && namedBindings.kind === SyntaxKind.NamespaceImport) { handleNamespaceImportLike(namedBindings.name); return; } @@ -333,13 +348,13 @@ namespace ts.FindAllReferences { if (sourceFile.flags & NodeFlags.JavaScriptFile) { // Find all 'require()' calls. - recur(sourceFile); - function recur(node: Node): void { + sourceFile.forEachChild(function recur(node: Node): void { if (isRequireCall(node, /*checkArgumentIsStringLiteral*/true)) { action(node, node.arguments[0] as StringLiteral); + } else { + node.forEachChild(recur); } - forEachChild(node, recur); - } + }); } } } @@ -379,18 +394,9 @@ namespace ts.FindAllReferences { if (parent.kind === SyntaxKind.PropertyAccessExpression) { // When accessing an export of a JS module, there's no alias. The symbol will still be flagged as an export even though we're at the use. // So check that we are at the declaration. - if (!symbol.declarations.some(d => d === parent)) { - return undefined; - } - - switch (getSpecialPropertyAssignmentKind(parent.parent)) { - case SpecialPropertyAssignmentKind.ExportsProperty: - return exportInfo(symbol, ExportKind.Named); - case SpecialPropertyAssignmentKind.ModuleExports: - return exportInfo(symbol, ExportKind.ExportEquals); - default: - return undefined; - } + return symbol.declarations.some(d => d === parent) && parent.parent.kind === ts.SyntaxKind.BinaryExpression + ? getSpecialPropertyExport(parent.parent as ts.BinaryExpression, /*useLhsSymbol*/ false) + : undefined; } else { const { exportSymbol } = symbol; @@ -420,6 +426,29 @@ namespace ts.FindAllReferences { Debug.assert(!!exportingModuleSymbol); return { kind: ImportExport.Export, symbol, exportInfo: { exportingModuleSymbol, exportKind: ExportKind.ExportEquals } }; } + else if (parent.kind === ts.SyntaxKind.BinaryExpression) { + return getSpecialPropertyExport(parent as ts.BinaryExpression, /*useLhsSymbol*/ true); + } + else if (parent.parent.kind === SyntaxKind.BinaryExpression) { + return getSpecialPropertyExport(parent.parent as ts.BinaryExpression, /*useLhsSymbol*/ true); + } + } + + function getSpecialPropertyExport(node: ts.BinaryExpression, useLhsSymbol: boolean): ExportedSymbol | undefined { + let kind: ExportKind; + switch (getSpecialPropertyAssignmentKind(node)) { + case SpecialPropertyAssignmentKind.ExportsProperty: + kind = ExportKind.Named; + break; + case SpecialPropertyAssignmentKind.ModuleExports: + kind = ExportKind.ExportEquals; + break; + default: + return undefined; + } + + const sym = useLhsSymbol ? checker.getSymbolAtLocation((node.left as ts.PropertyAccessExpression).name) : symbol; + return sym && exportInfo(sym, kind); } } diff --git a/tests/cases/fourslash/renameJsExports02.ts b/tests/cases/fourslash/renameJsExports02.ts new file mode 100644 index 00000000000..94c84980784 --- /dev/null +++ b/tests/cases/fourslash/renameJsExports02.ts @@ -0,0 +1,16 @@ +/// + +// @allowJs: true +// @Filename: a.js +////module.exports = class [|{| "isWriteAccess": true, "isDefinition": true |}A|] {} + +// @Filename: b.js +////const [|{| "isWriteAccess": true, "isDefinition": true |}A|] = require("./a"); + +const [r0, r1] = test.ranges(); +verify.referenceGroups(r0, [ + { definition: "(local class) A", ranges: [r0] }, + { definition: "const A: typeof A", ranges: [r1] } +]); + +verify.singleReferenceGroup("const A: typeof A", [r1]); diff --git a/tests/cases/fourslash/renameJsExports03.ts b/tests/cases/fourslash/renameJsExports03.ts new file mode 100644 index 00000000000..0ffd4d04692 --- /dev/null +++ b/tests/cases/fourslash/renameJsExports03.ts @@ -0,0 +1,31 @@ +/// + +// @allowJs: true +// @Filename: a.js +////class [|{| "isWriteAccess": true, "isDefinition": true |}A|] { +//// [|constructor|]() { } +////} +////module.exports = [|A|]; + +// @Filename: b.js +////const [|{| "isWriteAccess": true, "isDefinition": true |}A|] = require("./a"); +////new [|A|]; + +const [r0, r1, r2, r3, r4] = test.ranges(); +verify.referenceGroups([r0, r2], [ + { definition: "class A", ranges: [r0, r2] }, + { definition: "const A: typeof A", ranges: [r3, r4] } +]); + +verify.referenceGroups(r1, [ + { definition: "constructor A(): A", ranges: [r1] }, + { definition: "const A: typeof A", ranges: [r4] } +]); + +verify.referenceGroups(r3, [ + { definition: "const A: typeof A", ranges: [r3, r4] } +]); +verify.referenceGroups(r4, [ + { definition: "const A: new () => A", ranges: [r3, r4] } +]); + From eb09c11e4809bf3b970165fd4a1152333949e456 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Tue, 28 Mar 2017 10:34:21 -0700 Subject: [PATCH 15/35] Call the cancellationToken once per SourceFile, instead of calling it at every possible position. --- src/services/findAllReferences.ts | 46 ++++++++++++------------------- src/services/importTracker.ts | 19 +++++++++---- 2 files changed, 32 insertions(+), 33 deletions(-) diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts index d909419def4..0b4879ddf5d 100644 --- a/src/services/findAllReferences.ts +++ b/src/services/findAllReferences.ts @@ -305,11 +305,11 @@ namespace ts.FindAllReferences.Core { const labelDefinition = getTargetLabel((node.parent), (node).text); // if we have a label definition, look within its statement for references, if not, then // the label is undefined and we have no results.. - return labelDefinition && getLabelReferencesInNode(labelDefinition.parent, labelDefinition, cancellationToken); + return labelDefinition && getLabelReferencesInNode(labelDefinition.parent, labelDefinition); } else { // it is a label definition and not a target, search within the parent labeledStatement - return getLabelReferencesInNode(node.parent, node, cancellationToken); + return getLabelReferencesInNode(node.parent, node); } } @@ -318,7 +318,7 @@ namespace ts.FindAllReferences.Core { } if (node.kind === SyntaxKind.SuperKeyword) { - return getReferencesForSuperKeyword(node, cancellationToken); + return getReferencesForSuperKeyword(node); } return undefined; @@ -460,7 +460,7 @@ namespace ts.FindAllReferences.Core { }; function getImportSearches(exportSymbol: Symbol, exportInfo: ExportInfo): ImportsResult { - if (!importTracker) importTracker = createImportTracker(sourceFiles, checker); + if (!importTracker) importTracker = createImportTracker(sourceFiles, checker, cancellationToken); return importTracker(exportSymbol, exportInfo, options.isForRename); } @@ -515,7 +515,6 @@ namespace ts.FindAllReferences.Core { // For each import, find all references to that import in its source file. for (const [importLocation, importSymbol] of importSearches) { - state.cancellationToken.throwIfCancellationRequested(); getReferencesInSourceFile(importLocation.getSourceFile(), state.createSearch(importLocation, importSymbol, ImportExport.Export), state); } @@ -534,7 +533,6 @@ namespace ts.FindAllReferences.Core { } if (indirectSearch) { for (const indirectUser of indirectUsers) { - state.cancellationToken.throwIfCancellationRequested(); searchForName(indirectUser, indirectSearch, state); } } @@ -648,7 +646,7 @@ namespace ts.FindAllReferences.Core { return parent ? scope.getSourceFile() : scope; } - function getPossibleSymbolReferencePositions(sourceFile: SourceFile, symbolName: string, start: number, end: number, cancellationToken: CancellationToken): number[] { + function getPossibleSymbolReferencePositions(sourceFile: SourceFile, symbolName: string, start: number, end: number): number[] { const positions: number[] = []; /// TODO: Cache symbol existence for files to save text search @@ -665,8 +663,6 @@ namespace ts.FindAllReferences.Core { let position = text.indexOf(symbolName, start); while (position >= 0) { - cancellationToken.throwIfCancellationRequested(); - // If we are past the end, stop looking if (position > end) break; @@ -685,14 +681,12 @@ namespace ts.FindAllReferences.Core { return positions; } - function getLabelReferencesInNode(container: Node, targetLabel: Identifier, cancellationToken: CancellationToken): SymbolAndEntries[] { + function getLabelReferencesInNode(container: Node, targetLabel: Identifier): SymbolAndEntries[] { const references: Entry[] = []; const sourceFile = container.getSourceFile(); const labelName = targetLabel.text; - const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, labelName, container.getStart(), container.getEnd(), cancellationToken); + const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, labelName, container.getStart(), container.getEnd()); for (const position of possiblePositions) { - cancellationToken.throwIfCancellationRequested(); - const node = getTouchingWord(sourceFile, position); if (!node || node.getWidth() !== labelName.length) { continue; @@ -731,15 +725,14 @@ namespace ts.FindAllReferences.Core { const references: NodeEntry[] = []; for (const sourceFile of sourceFiles) { cancellationToken.throwIfCancellationRequested(); - addReferencesForKeywordInFile(sourceFile, keywordKind, tokenToString(keywordKind), cancellationToken, references); + addReferencesForKeywordInFile(sourceFile, keywordKind, tokenToString(keywordKind), references); } return references.length ? [{ definition: { type: "keyword", node: references[0].node }, references }] : undefined; } - function addReferencesForKeywordInFile(sourceFile: SourceFile, kind: SyntaxKind, searchText: string, cancellationToken: CancellationToken, references: Push): void { - const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, sourceFile.getStart(), sourceFile.getEnd(), cancellationToken); + function addReferencesForKeywordInFile(sourceFile: SourceFile, kind: SyntaxKind, searchText: string, references: Push): void { + const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, sourceFile.getStart(), sourceFile.getEnd()); for (const position of possiblePositions) { - cancellationToken.throwIfCancellationRequested(); const referenceLocation = getTouchingPropertyName(sourceFile, position); if (referenceLocation.kind === kind) { references.push(nodeEntry(referenceLocation)); @@ -748,6 +741,7 @@ namespace ts.FindAllReferences.Core { } function getReferencesInSourceFile(sourceFile: ts.SourceFile, search: Search, state: State): void { + state.cancellationToken.throwIfCancellationRequested(); return getReferencesInContainer(sourceFile, sourceFile, search, state); } @@ -762,9 +756,8 @@ namespace ts.FindAllReferences.Core { } const start = state.findInComments ? container.getFullStart() : container.getStart(); - const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, search.text, start, container.getEnd(), state.cancellationToken); + const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, search.text, start, container.getEnd()); for (const position of possiblePositions) { - state.cancellationToken.throwIfCancellationRequested(); getReferencesAtLocation(sourceFile, position, search, state); } } @@ -1182,7 +1175,7 @@ namespace ts.FindAllReferences.Core { } } - function getReferencesForSuperKeyword(superKeyword: Node, cancellationToken: CancellationToken): SymbolAndEntries[] { + function getReferencesForSuperKeyword(superKeyword: Node): SymbolAndEntries[] { let searchSpaceNode = getSuperContainer(superKeyword, /*stopOnFunctions*/ false); if (!searchSpaceNode) { return undefined; @@ -1208,10 +1201,8 @@ namespace ts.FindAllReferences.Core { const references: Entry[] = []; const sourceFile = searchSpaceNode.getSourceFile(); - const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "super", searchSpaceNode.getStart(), searchSpaceNode.getEnd(), cancellationToken); + const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "super", searchSpaceNode.getStart(), searchSpaceNode.getEnd()); for (const position of possiblePositions) { - cancellationToken.throwIfCancellationRequested(); - const node = getTouchingWord(sourceFile, position); if (!node || node.kind !== SyntaxKind.SuperKeyword) { @@ -1271,13 +1262,14 @@ namespace ts.FindAllReferences.Core { let possiblePositions: number[]; if (searchSpaceNode.kind === SyntaxKind.SourceFile) { forEach(sourceFiles, sourceFile => { - possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd(), cancellationToken); + cancellationToken.throwIfCancellationRequested(); + possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd()); getThisReferencesInFile(sourceFile, sourceFile, possiblePositions, references); }); } else { const sourceFile = searchSpaceNode.getSourceFile(); - possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", searchSpaceNode.getStart(), searchSpaceNode.getEnd(), cancellationToken); + possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", searchSpaceNode.getStart(), searchSpaceNode.getEnd()); getThisReferencesInFile(sourceFile, searchSpaceNode, possiblePositions, references); } @@ -1288,8 +1280,6 @@ namespace ts.FindAllReferences.Core { function getThisReferencesInFile(sourceFile: SourceFile, searchSpaceNode: Node, possiblePositions: number[], result: Entry[]): void { forEach(possiblePositions, position => { - cancellationToken.throwIfCancellationRequested(); - const node = getTouchingWord(sourceFile, position); if (!node || !isThis(node)) { return; @@ -1333,7 +1323,7 @@ namespace ts.FindAllReferences.Core { for (const sourceFile of sourceFiles) { cancellationToken.throwIfCancellationRequested(); - const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, node.text, sourceFile.getStart(), sourceFile.getEnd(), cancellationToken); + const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, node.text, sourceFile.getStart(), sourceFile.getEnd()); getReferencesForStringLiteralInFile(sourceFile, node.text, possiblePositions, references); } diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts index b9b0d319844..6e7d22f721e 100644 --- a/src/services/importTracker.ts +++ b/src/services/importTracker.ts @@ -12,10 +12,10 @@ namespace ts.FindAllReferences { export type ImportTracker = (exportSymbol: Symbol, exportInfo: ExportInfo, isForRename: boolean) => ImportsResult; /** Creates the imports map and returns an ImportTracker that uses it. Call this lazily to avoid calling `getDirectImportsMap` unnecessarily. */ - export function createImportTracker(sourceFiles: SourceFile[], checker: TypeChecker): ImportTracker { - const allDirectImports = getDirectImportsMap(sourceFiles, checker); + export function createImportTracker(sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): ImportTracker { + const allDirectImports = getDirectImportsMap(sourceFiles, checker, cancellationToken); return (exportSymbol, exportInfo, isForRename) => { - const { directImports, indirectUsers } = getImportersForExport(sourceFiles, allDirectImports, exportInfo, checker); + const { directImports, indirectUsers } = getImportersForExport(sourceFiles, allDirectImports, exportInfo, checker, cancellationToken); return { indirectUsers, ...getSearchesFromDirectImports(directImports, exportSymbol, exportInfo.exportKind, checker, isForRename) }; }; } @@ -37,7 +37,13 @@ namespace ts.FindAllReferences { type ImporterOrCallExpression = Importer | CallExpression; /** Returns import statements that directly reference the exporting module, and a list of files that may access the module through a namespace. */ - function getImportersForExport(sourceFiles: SourceFile[], allDirectImports: Map, { exportingModuleSymbol, exportKind }: ExportInfo, checker: TypeChecker): { directImports: Importer[], indirectUsers: SourceFile[] } { + function getImportersForExport( + sourceFiles: SourceFile[], + allDirectImports: Map, + { exportingModuleSymbol, exportKind }: ExportInfo, + checker: TypeChecker, + cancellationToken: CancellationToken + ): { directImports: Importer[], indirectUsers: SourceFile[] } { const markSeenDirectImport = nodeSeenTracker(); const markSeenIndirectUser = nodeSeenTracker(); const directImports: Importer[] = []; @@ -72,6 +78,8 @@ namespace ts.FindAllReferences { continue; } + cancellationToken.throwIfCancellationRequested(); + switch (direct.kind) { case SyntaxKind.CallExpression: if (!isAvailableThroughGlobal) { @@ -289,10 +297,11 @@ namespace ts.FindAllReferences { } /** Returns a map from a module symbol Id to all import statements that directly reference the module. */ - function getDirectImportsMap(sourceFiles: SourceFile[], checker: TypeChecker): Map { + function getDirectImportsMap(sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): Map { const map = createMap(); for (const sourceFile of sourceFiles) { + cancellationToken.throwIfCancellationRequested(); forEachImport(sourceFile, (importDecl, moduleSpecifier) => { const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier); if (moduleSymbol) { From 924f536ba67a80b7cb40981f42919a719e02b440 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 5 Apr 2017 11:02:42 -0700 Subject: [PATCH 16/35] Stop looking at control flow containers for `this` References to `this` should not continue looking outside their immediate container to narrow. Introduced by #11458, which allows narrowing of captured variables inside methods of class expressions. --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 7bdde91f286..fe9389bce0a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -11009,7 +11009,7 @@ namespace ts { else if (flow.flags & FlowFlags.Start) { // Check if we should continue with the control flow of the containing function. const container = (flow).container; - if (container && container !== flowContainer && reference.kind !== SyntaxKind.PropertyAccessExpression) { + if (container && container !== flowContainer && reference.kind !== SyntaxKind.PropertyAccessExpression && reference.kind !== SyntaxKind.ThisKeyword) { flow = container.flowNode; continue; } From db3431e3af4ce7153cf1b29f7aae5fb10b97d6f5 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 5 Apr 2017 11:06:14 -0700 Subject: [PATCH 17/35] Add `this` narrowing test and update previous test --- .../cases/compiler/anonymousClassExpression2.ts | 17 +++++++++++++++++ tests/cases/compiler/narrowedConstInMethod.ts | 7 ++++--- 2 files changed, 21 insertions(+), 3 deletions(-) create mode 100644 tests/cases/compiler/anonymousClassExpression2.ts diff --git a/tests/cases/compiler/anonymousClassExpression2.ts b/tests/cases/compiler/anonymousClassExpression2.ts new file mode 100644 index 00000000000..85095f6a8da --- /dev/null +++ b/tests/cases/compiler/anonymousClassExpression2.ts @@ -0,0 +1,17 @@ +// Fixes #14860 +// note: repros with `while (0);` too +// but it's less inscrutable and more obvious to put it *inside* the loop +while (0) { + class A { + methodA() { + this; //note: a this reference of some kind is required to trigger the bug + } + } + + class B { + methodB() { + this.methodA; // error + this.methodB; // ok + } + } +} diff --git a/tests/cases/compiler/narrowedConstInMethod.ts b/tests/cases/compiler/narrowedConstInMethod.ts index 3ddf97a8df3..14bac690a64 100644 --- a/tests/cases/compiler/narrowedConstInMethod.ts +++ b/tests/cases/compiler/narrowedConstInMethod.ts @@ -1,10 +1,11 @@ // @strictNullChecks: true +// Fixes #10501, possibly null 'x' function f() { const x: string | null = {}; if (x !== null) { return { - bar() { return x.length; } // Error: possibly null x + bar() { return x.length; } // ok }; } } @@ -13,7 +14,7 @@ function f2() { const x: string | null = {}; if (x !== null) { return class { - bar() { return x.length; } // Error: possibly null x + bar() { return x.length; } // ok }; } -} \ No newline at end of file +} From 6e149dd019f25faa3f5b817f7b638cc2ad6480a9 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 5 Apr 2017 11:06:40 -0700 Subject: [PATCH 18/35] Update baselines --- .../anonymousClassExpression2.errors.txt | 24 +++++++++++ .../reference/anonymousClassExpression2.js | 43 +++++++++++++++++++ .../reference/narrowedConstInMethod.js | 13 +++--- .../reference/narrowedConstInMethod.symbols | 24 ++++++----- .../reference/narrowedConstInMethod.types | 10 +++-- 5 files changed, 94 insertions(+), 20 deletions(-) create mode 100644 tests/baselines/reference/anonymousClassExpression2.errors.txt create mode 100644 tests/baselines/reference/anonymousClassExpression2.js diff --git a/tests/baselines/reference/anonymousClassExpression2.errors.txt b/tests/baselines/reference/anonymousClassExpression2.errors.txt new file mode 100644 index 00000000000..c9b59ae9c4d --- /dev/null +++ b/tests/baselines/reference/anonymousClassExpression2.errors.txt @@ -0,0 +1,24 @@ +tests/cases/compiler/anonymousClassExpression2.ts(13,18): error TS2339: Property 'methodA' does not exist on type 'B'. + + +==== tests/cases/compiler/anonymousClassExpression2.ts (1 errors) ==== + // Fixes #14860 + // note: repros with `while (0);` too + // but it's less inscrutable and more obvious to put it *inside* the loop + while (0) { + class A { + methodA() { + this; //note: a this reference of some kind is required to trigger the bug + } + } + + class B { + methodB() { + this.methodA; // error + ~~~~~~~ +!!! error TS2339: Property 'methodA' does not exist on type 'B'. + this.methodB; // ok + } + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/anonymousClassExpression2.js b/tests/baselines/reference/anonymousClassExpression2.js new file mode 100644 index 00000000000..a1da8d5fb10 --- /dev/null +++ b/tests/baselines/reference/anonymousClassExpression2.js @@ -0,0 +1,43 @@ +//// [anonymousClassExpression2.ts] +// Fixes #14860 +// note: repros with `while (0);` too +// but it's less inscrutable and more obvious to put it *inside* the loop +while (0) { + class A { + methodA() { + this; //note: a this reference of some kind is required to trigger the bug + } + } + + class B { + methodB() { + this.methodA; // error + this.methodB; // ok + } + } +} + + +//// [anonymousClassExpression2.js] +// Fixes #14860 +// note: repros with `while (0);` too +// but it's less inscrutable and more obvious to put it *inside* the loop +while (0) { + var A = (function () { + function A() { + } + A.prototype.methodA = function () { + this; //note: a this reference of some kind is required to trigger the bug + }; + return A; + }()); + var B = (function () { + function B() { + } + B.prototype.methodB = function () { + this.methodA; // error + this.methodB; // ok + }; + return B; + }()); +} diff --git a/tests/baselines/reference/narrowedConstInMethod.js b/tests/baselines/reference/narrowedConstInMethod.js index e2bd1c1cd21..e86b6df6a46 100644 --- a/tests/baselines/reference/narrowedConstInMethod.js +++ b/tests/baselines/reference/narrowedConstInMethod.js @@ -1,9 +1,10 @@ //// [narrowedConstInMethod.ts] +// Fixes #10501, possibly null 'x' function f() { const x: string | null = {}; if (x !== null) { return { - bar() { return x.length; } // Error: possibly null x + bar() { return x.length; } // ok }; } } @@ -12,17 +13,19 @@ function f2() { const x: string | null = {}; if (x !== null) { return class { - bar() { return x.length; } // Error: possibly null x + bar() { return x.length; } // ok }; } -} +} + //// [narrowedConstInMethod.js] +// Fixes #10501, possibly null 'x' function f() { var x = {}; if (x !== null) { return { - bar: function () { return x.length; } // Error: possibly null x + bar: function () { return x.length; } // ok }; } } @@ -32,7 +35,7 @@ function f2() { return (function () { function class_1() { } - class_1.prototype.bar = function () { return x.length; }; // Error: possibly null x + class_1.prototype.bar = function () { return x.length; }; // ok return class_1; }()); } diff --git a/tests/baselines/reference/narrowedConstInMethod.symbols b/tests/baselines/reference/narrowedConstInMethod.symbols index f16837bf1bd..75f8620d19c 100644 --- a/tests/baselines/reference/narrowedConstInMethod.symbols +++ b/tests/baselines/reference/narrowedConstInMethod.symbols @@ -1,18 +1,19 @@ === tests/cases/compiler/narrowedConstInMethod.ts === +// Fixes #10501, possibly null 'x' function f() { >f : Symbol(f, Decl(narrowedConstInMethod.ts, 0, 0)) const x: string | null = {}; ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9)) if (x !== null) { ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9)) return { - bar() { return x.length; } // Error: possibly null x ->bar : Symbol(bar, Decl(narrowedConstInMethod.ts, 3, 16)) + bar() { return x.length; } // ok +>bar : Symbol(bar, Decl(narrowedConstInMethod.ts, 4, 16)) >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) }; @@ -20,21 +21,22 @@ function f() { } function f2() { ->f2 : Symbol(f2, Decl(narrowedConstInMethod.ts, 7, 1)) +>f2 : Symbol(f2, Decl(narrowedConstInMethod.ts, 8, 1)) const x: string | null = {}; ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9)) if (x !== null) { ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9)) return class { - bar() { return x.length; } // Error: possibly null x ->bar : Symbol((Anonymous class).bar, Decl(narrowedConstInMethod.ts, 12, 22)) + bar() { return x.length; } // ok +>bar : Symbol((Anonymous class).bar, Decl(narrowedConstInMethod.ts, 13, 22)) >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9)) +>x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9)) >length : Symbol(String.length, Decl(lib.d.ts, --, --)) }; } } + diff --git a/tests/baselines/reference/narrowedConstInMethod.types b/tests/baselines/reference/narrowedConstInMethod.types index 1f3886cc588..9fa0c12473f 100644 --- a/tests/baselines/reference/narrowedConstInMethod.types +++ b/tests/baselines/reference/narrowedConstInMethod.types @@ -1,4 +1,5 @@ === tests/cases/compiler/narrowedConstInMethod.ts === +// Fixes #10501, possibly null 'x' function f() { >f : () => { bar(): number; } | undefined @@ -14,9 +15,9 @@ function f() { >null : null return { ->{ bar() { return x.length; } // Error: possibly null x } : { bar(): number; } +>{ bar() { return x.length; } // ok } : { bar(): number; } - bar() { return x.length; } // Error: possibly null x + bar() { return x.length; } // ok >bar : () => number >x.length : number >x : string @@ -41,9 +42,9 @@ function f2() { >null : null return class { ->class { bar() { return x.length; } // Error: possibly null x } : typeof (Anonymous class) +>class { bar() { return x.length; } // ok } : typeof (Anonymous class) - bar() { return x.length; } // Error: possibly null x + bar() { return x.length; } // ok >bar : () => number >x.length : number >x : string @@ -52,3 +53,4 @@ function f2() { }; } } + From 8a851f3702c539feb86ad766a8efa403f9d080c4 Mon Sep 17 00:00:00 2001 From: falsandtru Date: Tue, 11 Apr 2017 21:10:33 +0900 Subject: [PATCH 19/35] Use `object` type --- src/lib/es2015.collection.d.ts | 12 +++++----- src/lib/es2015.core.d.ts | 2 +- src/lib/es2015.iterable.d.ts | 6 ++--- src/lib/es2015.proxy.d.ts | 6 ++--- src/lib/es2015.reflect.d.ts | 24 +++++++++---------- src/lib/es2015.symbol.wellknown.d.ts | 2 +- ...eLibrary_NoErrorDuplicateLibOptions1.types | 4 ++-- ...eLibrary_NoErrorDuplicateLibOptions2.types | 4 ++-- ...dularizeLibrary_TargetES5UsingES6Lib.types | 4 ++-- ...dularizeLibrary_TargetES6UsingES6Lib.types | 4 ++-- ...Library_UsingES5LibAndES6FeatureLibs.types | 4 ++-- 11 files changed, 36 insertions(+), 36 deletions(-) diff --git a/src/lib/es2015.collection.d.ts b/src/lib/es2015.collection.d.ts index b2255dab881..038ed1ed58c 100644 --- a/src/lib/es2015.collection.d.ts +++ b/src/lib/es2015.collection.d.ts @@ -30,9 +30,9 @@ interface WeakMap { } interface WeakMapConstructor { - new (): WeakMap; + new (): WeakMap; new (entries?: [K, V][]): WeakMap; - readonly prototype: WeakMap; + readonly prototype: WeakMap; } declare var WeakMap: WeakMapConstructor; @@ -58,15 +58,15 @@ interface ReadonlySet { readonly size: number; } -interface WeakSet { +interface WeakSet { add(value: T): this; delete(value: T): boolean; has(value: T): boolean; } interface WeakSetConstructor { - new (): WeakSet; - new (values?: T[]): WeakSet; - readonly prototype: WeakSet; + new (): WeakSet; + new (values?: T[]): WeakSet; + readonly prototype: WeakSet; } declare var WeakSet: WeakSetConstructor; diff --git a/src/lib/es2015.core.d.ts b/src/lib/es2015.core.d.ts index 341fd80872c..9e4399071fa 100644 --- a/src/lib/es2015.core.d.ts +++ b/src/lib/es2015.core.d.ts @@ -311,7 +311,7 @@ interface ObjectConstructor { * @param target The target object to copy to. * @param sources One or more source objects from which to copy properties */ - assign(target: any, ...sources: any[]): any; + assign(target: object, ...sources: any[]): any; /** * Returns an array of all symbol properties found directly on object o. diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts index 03c583dc155..2d382b67adc 100644 --- a/src/lib/es2015.iterable.d.ts +++ b/src/lib/es2015.iterable.d.ts @@ -118,10 +118,10 @@ interface SetConstructor { new (iterable: Iterable): Set; } -interface WeakSet { } +interface WeakSet { } interface WeakSetConstructor { - new (iterable: Iterable): WeakSet; + new (iterable: Iterable): WeakSet; } interface Promise { } @@ -145,7 +145,7 @@ interface PromiseConstructor { } declare namespace Reflect { - function enumerate(target: any): IterableIterator; + function enumerate(target: object): IterableIterator; } interface String { diff --git a/src/lib/es2015.proxy.d.ts b/src/lib/es2015.proxy.d.ts index 89f9ebf55c0..c1b7805bbcf 100644 --- a/src/lib/es2015.proxy.d.ts +++ b/src/lib/es2015.proxy.d.ts @@ -1,4 +1,4 @@ -interface ProxyHandler { +interface ProxyHandler { getPrototypeOf? (target: T): object | null; setPrototypeOf? (target: T, v: any): boolean; isExtensible? (target: T): boolean; @@ -16,7 +16,7 @@ interface ProxyHandler { } interface ProxyConstructor { - revocable(target: T, handler: ProxyHandler): { proxy: T; revoke: () => void; }; - new (target: T, handler: ProxyHandler): T; + revocable(target: T, handler: ProxyHandler): { proxy: T; revoke: () => void; }; + new (target: T, handler: ProxyHandler): T; } declare var Proxy: ProxyConstructor; diff --git a/src/lib/es2015.reflect.d.ts b/src/lib/es2015.reflect.d.ts index 2dc92c3bddb..83755e4c791 100644 --- a/src/lib/es2015.reflect.d.ts +++ b/src/lib/es2015.reflect.d.ts @@ -1,15 +1,15 @@ declare namespace Reflect { function apply(target: Function, thisArgument: any, argumentsList: ArrayLike): any; function construct(target: Function, argumentsList: ArrayLike, newTarget?: any): any; - function defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean; - function deleteProperty(target: any, propertyKey: PropertyKey): boolean; - function get(target: any, propertyKey: PropertyKey, receiver?: any): any; - function getOwnPropertyDescriptor(target: any, propertyKey: PropertyKey): PropertyDescriptor; - function getPrototypeOf(target: any): any; - function has(target: any, propertyKey: PropertyKey): boolean; - function isExtensible(target: any): boolean; - function ownKeys(target: any): Array; - function preventExtensions(target: any): boolean; - function set(target: any, propertyKey: PropertyKey, value: any, receiver?: any): boolean; - function setPrototypeOf(target: any, proto: any): boolean; -} \ No newline at end of file + function defineProperty(target: object, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean; + function deleteProperty(target: object, propertyKey: PropertyKey): boolean; + function get(target: object, propertyKey: PropertyKey, receiver?: any): any; + function getOwnPropertyDescriptor(target: object, propertyKey: PropertyKey): PropertyDescriptor; + function getPrototypeOf(target: object): object; + function has(target: object, propertyKey: PropertyKey): boolean; + function isExtensible(target: object): boolean; + function ownKeys(target: object): Array; + function preventExtensions(target: object): boolean; + function set(target: object, propertyKey: PropertyKey, value: any, receiver?: any): boolean; + function setPrototypeOf(target: object, proto: any): boolean; +} diff --git a/src/lib/es2015.symbol.wellknown.d.ts b/src/lib/es2015.symbol.wellknown.d.ts index 578cf0acbc2..3d030f37d49 100644 --- a/src/lib/es2015.symbol.wellknown.d.ts +++ b/src/lib/es2015.symbol.wellknown.d.ts @@ -118,7 +118,7 @@ interface Set { readonly [Symbol.toStringTag]: "Set"; } -interface WeakSet { +interface WeakSet { readonly [Symbol.toStringTag]: "WeakSet"; } diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types index 7012b25ccbd..844ac1919d5 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types @@ -177,9 +177,9 @@ var p = new Proxy(t, {}); // Using ES6 reflect Reflect.isExtensible({}); >Reflect.isExtensible({}) : boolean ->Reflect.isExtensible : (target: any) => boolean +>Reflect.isExtensible : (target: object) => boolean >Reflect : typeof Reflect ->isExtensible : (target: any) => boolean +>isExtensible : (target: object) => boolean >{} : {} // Using Es6 regexp diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types index 781e33e850a..708e7727ba3 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types @@ -177,9 +177,9 @@ var p = new Proxy(t, {}); // Using ES6 reflect Reflect.isExtensible({}); >Reflect.isExtensible({}) : boolean ->Reflect.isExtensible : (target: any) => boolean +>Reflect.isExtensible : (target: object) => boolean >Reflect : typeof Reflect ->isExtensible : (target: any) => boolean +>isExtensible : (target: object) => boolean >{} : {} // Using Es6 regexp diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types index 54c6958dccc..79695defe7b 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types @@ -177,9 +177,9 @@ var p = new Proxy(t, {}); // Using ES6 reflect Reflect.isExtensible({}); >Reflect.isExtensible({}) : boolean ->Reflect.isExtensible : (target: any) => boolean +>Reflect.isExtensible : (target: object) => boolean >Reflect : typeof Reflect ->isExtensible : (target: any) => boolean +>isExtensible : (target: object) => boolean >{} : {} // Using Es6 regexp diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types index 9dd896bc9e6..c40341e17cc 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types +++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types @@ -100,9 +100,9 @@ var p = new Proxy(t, {}); // Using ES6 reflect Reflect.isExtensible({}); >Reflect.isExtensible({}) : boolean ->Reflect.isExtensible : (target: any) => boolean +>Reflect.isExtensible : (target: object) => boolean >Reflect : typeof Reflect ->isExtensible : (target: any) => boolean +>isExtensible : (target: object) => boolean >{} : {} // Using Es6 regexp diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types index 281faddbc52..ab24aaf12ba 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types @@ -17,9 +17,9 @@ var p = new Proxy(t, {}); Reflect.ownKeys({}); >Reflect.ownKeys({}) : PropertyKey[] ->Reflect.ownKeys : (target: any) => PropertyKey[] +>Reflect.ownKeys : (target: object) => PropertyKey[] >Reflect : typeof Reflect ->ownKeys : (target: any) => PropertyKey[] +>ownKeys : (target: object) => PropertyKey[] >{} : {} function* idGen() { From 46eaf4feb0c9893c64a964b99cb949e790e227b3 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Tue, 11 Apr 2017 12:38:49 -0700 Subject: [PATCH 20/35] Remove `npm update`; add release-2.3 to branches This command *should* do nothing immediately following an `npm install`, but causes failures due to `tslint` having a dependency on `typescript`. Also add release-2.3 to our covered branches --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 5d6663ad6d6..7231d89d354 100644 --- a/.travis.yml +++ b/.travis.yml @@ -18,12 +18,12 @@ branches: - master - release-2.1 - release-2.2 + - release-2.3 install: - npm uninstall typescript - npm uninstall tslint - npm install - - npm update cache: directories: From 7b1cbf0994b251e34e75b35faccdb52d7ff0e373 Mon Sep 17 00:00:00 2001 From: Herrington Darkholme Date: Thu, 13 Apr 2017 21:30:17 +0800 Subject: [PATCH 21/35] fix #15155: improve namespaceModule error message --- src/compiler/checker.ts | 14 +++++++++++++- src/compiler/diagnosticMessages.json | 4 ++++ 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 5d7814f59f7..920bbceb6cf 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1056,7 +1056,8 @@ namespace ts { !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) && !checkAndReportErrorForExtendingInterface(errorLocation) && !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) && - !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning)) { + !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) && + !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning)) { error(errorLocation, nameNotFoundMessage, typeof nameArg === "string" ? nameArg : declarationNameToString(nameArg)); } } @@ -1200,6 +1201,17 @@ namespace ts { return false; } + function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation: Node, name: string, meaning: SymbolFlags): boolean { + if (meaning & (SymbolFlags.Value & ~SymbolFlags.NamespaceModule)) { + const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.NamespaceModule & ~SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined)); + if (symbol) { + error(errorLocation, Diagnostics.Cannot_use_namespace_0_as_a_value_here_because_it_has_no_value_export, name); + return true; + } + } + return false; + } + function checkResolvedBlockScopedVariable(result: Symbol, errorLocation: Node): void { Debug.assert(!!(result.flags & SymbolFlags.BlockScopedVariable || result.flags & SymbolFlags.Class || result.flags & SymbolFlags.Enum)); // Block-scoped variables cannot be used before their definition diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 075d4247460..4e70cf65849 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -2099,6 +2099,10 @@ "category": "Error", "code": 2707 }, + "Cannot use namespace '{0}' as a value here because it has no value export.": { + "category": "Error", + "code": 2708 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", From aab25a891a0b514038e31aaca7fc01780bbd1d02 Mon Sep 17 00:00:00 2001 From: Herrington Darkholme Date: Thu, 13 Apr 2017 21:30:40 +0800 Subject: [PATCH 22/35] accept new baselines --- .../InvalidNonInstantiatedModule.errors.txt | 8 ++++---- .../aliasOnMergedModuleInterface.errors.txt | 4 ++-- .../reference/assignToModule.errors.txt | 4 ++-- .../assignmentToReferenceTypes.errors.txt | 4 ++-- .../reference/assignments.errors.txt | 4 ++-- ...efaultArgsInFunctionExpressions.errors.txt | 4 ++-- ...peReferenceWithoutTypeArgument2.errors.txt | 4 ++-- .../importDeclWithClassModifiers.errors.txt | 12 ++++++------ .../importDeclWithDeclareModifier.errors.txt | 4 ++-- .../importDeclWithExportModifier.errors.txt | 4 ++-- ...portModifierAndExportAssignment.errors.txt | 4 ++-- .../importStatementsInterfaces.errors.txt | 4 ++-- .../interfaceNameAsIdentifier.errors.txt | 4 ++-- .../reference/memberScope.errors.txt | 4 ++-- .../reference/moduleAsBaseType.errors.txt | 12 ++++++------ .../moduleWithNoValuesAsType.errors.txt | 12 ++++++------ .../reference/namespaceModule.errors.txt | 19 +++++++++++++++++++ tests/baselines/reference/namespaceModule.js | 15 +++++++++++++++ .../typeUsedAsValueError2.errors.txt | 4 ++-- .../typeofInternalModules.errors.txt | 8 ++++---- tests/cases/compiler/namespaceModule.ts | 9 +++++++++ 21 files changed, 95 insertions(+), 52 deletions(-) create mode 100644 tests/baselines/reference/namespaceModule.errors.txt create mode 100644 tests/baselines/reference/namespaceModule.js create mode 100644 tests/cases/compiler/namespaceModule.ts diff --git a/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt b/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt index 9fd7043faa6..bcfb27652c9 100644 --- a/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt +++ b/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt @@ -1,5 +1,5 @@ -tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(5,9): error TS2304: Cannot find name 'M'. -tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(7,15): error TS2304: Cannot find name 'M'. +tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(5,9): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(7,15): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. ==== tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts (2 errors) ==== @@ -9,9 +9,9 @@ tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiate var m = M; // Error, not instantiated can not be used as var ~ -!!! error TS2304: Cannot find name 'M'. +!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. var x: typeof M; // Error only a namespace ~ -!!! error TS2304: Cannot find name 'M'. +!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. \ No newline at end of file diff --git a/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt b/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt index 009d405c0f5..ae56be397fe 100644 --- a/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt +++ b/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/aliasOnMergedModuleInterface_1.ts(5,16): error TS2304: Cannot find name 'foo'. +tests/cases/compiler/aliasOnMergedModuleInterface_1.ts(5,16): error TS2708: Cannot use namespace 'foo' as a value here because it has no value export. ==== tests/cases/compiler/aliasOnMergedModuleInterface_1.ts (1 errors) ==== @@ -8,7 +8,7 @@ tests/cases/compiler/aliasOnMergedModuleInterface_1.ts(5,16): error TS2304: Cann z.bar("hello"); // This should be ok var x: foo.A = foo.bar("hello"); // foo.A should be ok but foo.bar should be error ~~~ -!!! error TS2304: Cannot find name 'foo'. +!!! error TS2708: Cannot use namespace 'foo' as a value here because it has no value export. ==== tests/cases/compiler/aliasOnMergedModuleInterface_0.ts (0 errors) ==== declare module "foo" diff --git a/tests/baselines/reference/assignToModule.errors.txt b/tests/baselines/reference/assignToModule.errors.txt index 26121d72a05..f7abfa90bf7 100644 --- a/tests/baselines/reference/assignToModule.errors.txt +++ b/tests/baselines/reference/assignToModule.errors.txt @@ -1,8 +1,8 @@ -tests/cases/compiler/assignToModule.ts(2,1): error TS2304: Cannot find name 'A'. +tests/cases/compiler/assignToModule.ts(2,1): error TS2708: Cannot use namespace 'A' as a value here because it has no value export. ==== tests/cases/compiler/assignToModule.ts (1 errors) ==== module A {} A = undefined; // invalid LHS ~ -!!! error TS2304: Cannot find name 'A'. \ No newline at end of file +!!! error TS2708: Cannot use namespace 'A' as a value here because it has no value export. \ No newline at end of file diff --git a/tests/baselines/reference/assignmentToReferenceTypes.errors.txt b/tests/baselines/reference/assignmentToReferenceTypes.errors.txt index 7e323479d57..8c937e02766 100644 --- a/tests/baselines/reference/assignmentToReferenceTypes.errors.txt +++ b/tests/baselines/reference/assignmentToReferenceTypes.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/assignmentToReferenceTypes.ts(5,1): error TS2304: Cannot find name 'M'. +tests/cases/compiler/assignmentToReferenceTypes.ts(5,1): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. tests/cases/compiler/assignmentToReferenceTypes.ts(9,1): error TS2539: Cannot assign to 'C' because it is not a variable. tests/cases/compiler/assignmentToReferenceTypes.ts(13,1): error TS2539: Cannot assign to 'E' because it is not a variable. tests/cases/compiler/assignmentToReferenceTypes.ts(16,1): error TS2539: Cannot assign to 'f' because it is not a variable. @@ -11,7 +11,7 @@ tests/cases/compiler/assignmentToReferenceTypes.ts(16,1): error TS2539: Cannot a } M = null; ~ -!!! error TS2304: Cannot find name 'M'. +!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. class C { } diff --git a/tests/baselines/reference/assignments.errors.txt b/tests/baselines/reference/assignments.errors.txt index 86bbe75cd4b..2c3fff0be59 100644 --- a/tests/baselines/reference/assignments.errors.txt +++ b/tests/baselines/reference/assignments.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(11,1): error TS2304: Cannot find name 'M'. +tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(11,1): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(14,1): error TS2539: Cannot assign to 'C' because it is not a variable. tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(17,1): error TS2539: Cannot assign to 'E' because it is not a variable. tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(18,3): error TS2540: Cannot assign to 'A' because it is a constant or a read-only property. @@ -19,7 +19,7 @@ tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(31,1): er module M { } M = null; // Error ~ -!!! error TS2304: Cannot find name 'M'. +!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. class C { } C = null; // Error diff --git a/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt b/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt index b0b0f876be4..889a6c3ce79 100644 --- a/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt +++ b/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt @@ -5,7 +5,7 @@ tests/cases/compiler/defaultArgsInFunctionExpressions.ts(11,1): error TS2322: Ty tests/cases/compiler/defaultArgsInFunctionExpressions.ts(14,51): error TS2352: Type 'string' cannot be converted to type 'number'. tests/cases/compiler/defaultArgsInFunctionExpressions.ts(17,41): error TS2322: Type '""' is not assignable to type 'number'. tests/cases/compiler/defaultArgsInFunctionExpressions.ts(20,62): error TS2352: Type 'string' cannot be converted to type 'number'. -tests/cases/compiler/defaultArgsInFunctionExpressions.ts(28,15): error TS2304: Cannot find name 'T'. +tests/cases/compiler/defaultArgsInFunctionExpressions.ts(28,15): error TS2708: Cannot use namespace 'T' as a value here because it has no value export. ==== tests/cases/compiler/defaultArgsInFunctionExpressions.ts (8 errors) ==== @@ -52,7 +52,7 @@ tests/cases/compiler/defaultArgsInFunctionExpressions.ts(28,15): error TS2304: C var f6 = (t = T) => { }; ~ -!!! error TS2304: Cannot find name 'T'. +!!! error TS2708: Cannot use namespace 'T' as a value here because it has no value export. var f7 = (t = U) => { return t; }; f7().x; \ No newline at end of file diff --git a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt index 7635608f58e..05d88ae9d39 100644 --- a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt +++ b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt @@ -15,7 +15,7 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(18,38): error TS2314: Generic type 'I' requires 1 type argument(s). tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(20,17): error TS2689: Cannot extend an interface 'I'. Did you mean 'implements'? tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(23,21): error TS2314: Generic type 'I' requires 1 type argument(s). -tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(29,18): error TS2304: Cannot find name 'M'. +tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(29,18): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(30,24): error TS2314: Generic type 'E' requires 1 type argument(s). tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(31,24): error TS2694: Namespace 'M' has no exported member 'C'. tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(33,22): error TS2314: Generic type 'I' requires 1 type argument(s). @@ -89,7 +89,7 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc class D2 extends M.C { } ~ -!!! error TS2304: Cannot find name 'M'. +!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. interface D3 { } ~~~ !!! error TS2314: Generic type 'E' requires 1 type argument(s). diff --git a/tests/baselines/reference/importDeclWithClassModifiers.errors.txt b/tests/baselines/reference/importDeclWithClassModifiers.errors.txt index e1b8867d069..8c82322d384 100644 --- a/tests/baselines/reference/importDeclWithClassModifiers.errors.txt +++ b/tests/baselines/reference/importDeclWithClassModifiers.errors.txt @@ -1,11 +1,11 @@ tests/cases/compiler/importDeclWithClassModifiers.ts(5,8): error TS1044: 'public' modifier cannot appear on a module or namespace element. -tests/cases/compiler/importDeclWithClassModifiers.ts(5,26): error TS2304: Cannot find name 'x'. +tests/cases/compiler/importDeclWithClassModifiers.ts(5,26): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. tests/cases/compiler/importDeclWithClassModifiers.ts(5,28): error TS2694: Namespace 'x' has no exported member 'c'. tests/cases/compiler/importDeclWithClassModifiers.ts(6,8): error TS1044: 'private' modifier cannot appear on a module or namespace element. -tests/cases/compiler/importDeclWithClassModifiers.ts(6,27): error TS2304: Cannot find name 'x'. +tests/cases/compiler/importDeclWithClassModifiers.ts(6,27): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. tests/cases/compiler/importDeclWithClassModifiers.ts(6,29): error TS2694: Namespace 'x' has no exported member 'c'. tests/cases/compiler/importDeclWithClassModifiers.ts(7,8): error TS1044: 'static' modifier cannot appear on a module or namespace element. -tests/cases/compiler/importDeclWithClassModifiers.ts(7,26): error TS2304: Cannot find name 'x'. +tests/cases/compiler/importDeclWithClassModifiers.ts(7,26): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. tests/cases/compiler/importDeclWithClassModifiers.ts(7,28): error TS2694: Namespace 'x' has no exported member 'c'. @@ -18,21 +18,21 @@ tests/cases/compiler/importDeclWithClassModifiers.ts(7,28): error TS2694: Namesp ~~~~~~ !!! error TS1044: 'public' modifier cannot appear on a module or namespace element. ~ -!!! error TS2304: Cannot find name 'x'. +!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export private import b = x.c; ~~~~~~~ !!! error TS1044: 'private' modifier cannot appear on a module or namespace element. ~ -!!! error TS2304: Cannot find name 'x'. +!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export static import c = x.c; ~~~~~~ !!! error TS1044: 'static' modifier cannot appear on a module or namespace element. ~ -!!! error TS2304: Cannot find name 'x'. +!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. var b: a; diff --git a/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt b/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt index d69a88964cc..696926dd4a1 100644 --- a/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt +++ b/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/importDeclWithDeclareModifier.ts(5,9): error TS1029: 'export' modifier must precede 'declare' modifier. -tests/cases/compiler/importDeclWithDeclareModifier.ts(5,27): error TS2304: Cannot find name 'x'. +tests/cases/compiler/importDeclWithDeclareModifier.ts(5,27): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. tests/cases/compiler/importDeclWithDeclareModifier.ts(5,29): error TS2694: Namespace 'x' has no exported member 'c'. @@ -12,7 +12,7 @@ tests/cases/compiler/importDeclWithDeclareModifier.ts(5,29): error TS2694: Names ~~~~~~ !!! error TS1029: 'export' modifier must precede 'declare' modifier. ~ -!!! error TS2304: Cannot find name 'x'. +!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. var b: a; diff --git a/tests/baselines/reference/importDeclWithExportModifier.errors.txt b/tests/baselines/reference/importDeclWithExportModifier.errors.txt index 56e9a159afb..d211b750ca3 100644 --- a/tests/baselines/reference/importDeclWithExportModifier.errors.txt +++ b/tests/baselines/reference/importDeclWithExportModifier.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/importDeclWithExportModifier.ts(5,19): error TS2304: Cannot find name 'x'. +tests/cases/compiler/importDeclWithExportModifier.ts(5,19): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. tests/cases/compiler/importDeclWithExportModifier.ts(5,21): error TS2694: Namespace 'x' has no exported member 'c'. @@ -9,7 +9,7 @@ tests/cases/compiler/importDeclWithExportModifier.ts(5,21): error TS2694: Namesp } export import a = x.c; ~ -!!! error TS2304: Cannot find name 'x'. +!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. var b: a; diff --git a/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt b/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt index ff3c47e9f33..fbe7fde272d 100644 --- a/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt +++ b/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(5,19): error TS2304: Cannot find name 'x'. +tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(5,19): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(5,21): error TS2694: Namespace 'x' has no exported member 'c'. tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(6,1): error TS2309: An export assignment cannot be used in a module with other exported elements. @@ -10,7 +10,7 @@ tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(6,1): er } export import a = x.c; ~ -!!! error TS2304: Cannot find name 'x'. +!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export = x; diff --git a/tests/baselines/reference/importStatementsInterfaces.errors.txt b/tests/baselines/reference/importStatementsInterfaces.errors.txt index 313365fb191..d591997117f 100644 --- a/tests/baselines/reference/importStatementsInterfaces.errors.txt +++ b/tests/baselines/reference/importStatementsInterfaces.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/internalModules/codeGeneration/importStatementsInterfaces.ts(23,19): error TS2304: Cannot find name 'a'. +tests/cases/conformance/internalModules/codeGeneration/importStatementsInterfaces.ts(23,19): error TS2708: Cannot use namespace 'a' as a value here because it has no value export. ==== tests/cases/conformance/internalModules/codeGeneration/importStatementsInterfaces.ts (1 errors) ==== @@ -26,7 +26,7 @@ tests/cases/conformance/internalModules/codeGeneration/importStatementsInterface import b = a.inA; var m: typeof a; ~ -!!! error TS2304: Cannot find name 'a'. +!!! error TS2708: Cannot use namespace 'a' as a value here because it has no value export. var p: b.Point3D; var p = {x:0, y:0, z: 0 }; } diff --git a/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt b/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt index 5be40b5b7b6..faa6a0096fa 100644 --- a/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt +++ b/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/interfaceNameAsIdentifier.ts(4,1): error TS2693: 'C' only refers to a type, but is being used as a value here. -tests/cases/compiler/interfaceNameAsIdentifier.ts(12,1): error TS2304: Cannot find name 'm2'. +tests/cases/compiler/interfaceNameAsIdentifier.ts(12,1): error TS2708: Cannot use namespace 'm2' as a value here because it has no value export. ==== tests/cases/compiler/interfaceNameAsIdentifier.ts (2 errors) ==== @@ -18,5 +18,5 @@ tests/cases/compiler/interfaceNameAsIdentifier.ts(12,1): error TS2304: Cannot fi m2.C(); ~~ -!!! error TS2304: Cannot find name 'm2'. +!!! error TS2708: Cannot use namespace 'm2' as a value here because it has no value export. \ No newline at end of file diff --git a/tests/baselines/reference/memberScope.errors.txt b/tests/baselines/reference/memberScope.errors.txt index 017a28d5f71..1d69c350d7c 100644 --- a/tests/baselines/reference/memberScope.errors.txt +++ b/tests/baselines/reference/memberScope.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/memberScope.ts(4,11): error TS2304: Cannot find name 'Basil'. +tests/cases/compiler/memberScope.ts(4,11): error TS2708: Cannot use namespace 'Basil' as a value here because it has no value export. ==== tests/cases/compiler/memberScope.ts (1 errors) ==== @@ -7,7 +7,7 @@ tests/cases/compiler/memberScope.ts(4,11): error TS2304: Cannot find name 'Basil export module Basil { } var z = Basil.Pepper; ~~~~~ -!!! error TS2304: Cannot find name 'Basil'. +!!! error TS2708: Cannot use namespace 'Basil' as a value here because it has no value export. } \ No newline at end of file diff --git a/tests/baselines/reference/moduleAsBaseType.errors.txt b/tests/baselines/reference/moduleAsBaseType.errors.txt index ffa30ad0ab3..5313c28fbae 100644 --- a/tests/baselines/reference/moduleAsBaseType.errors.txt +++ b/tests/baselines/reference/moduleAsBaseType.errors.txt @@ -1,16 +1,16 @@ -tests/cases/compiler/moduleAsBaseType.ts(2,17): error TS2304: Cannot find name 'M'. -tests/cases/compiler/moduleAsBaseType.ts(3,21): error TS2304: Cannot find name 'M'. -tests/cases/compiler/moduleAsBaseType.ts(4,21): error TS2304: Cannot find name 'M'. +tests/cases/compiler/moduleAsBaseType.ts(2,17): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +tests/cases/compiler/moduleAsBaseType.ts(3,21): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +tests/cases/compiler/moduleAsBaseType.ts(4,21): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. ==== tests/cases/compiler/moduleAsBaseType.ts (3 errors) ==== module M {} class C extends M {} ~ -!!! error TS2304: Cannot find name 'M'. +!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. interface I extends M { } ~ -!!! error TS2304: Cannot find name 'M'. +!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. class C2 implements M { } ~ -!!! error TS2304: Cannot find name 'M'. \ No newline at end of file +!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. \ No newline at end of file diff --git a/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt b/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt index c387f5d62f4..5636b97e8cd 100644 --- a/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt +++ b/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt @@ -1,20 +1,20 @@ -tests/cases/compiler/moduleWithNoValuesAsType.ts(2,8): error TS2304: Cannot find name 'A'. -tests/cases/compiler/moduleWithNoValuesAsType.ts(7,8): error TS2304: Cannot find name 'B'. -tests/cases/compiler/moduleWithNoValuesAsType.ts(15,8): error TS2304: Cannot find name 'C'. +tests/cases/compiler/moduleWithNoValuesAsType.ts(2,8): error TS2708: Cannot use namespace 'A' as a value here because it has no value export. +tests/cases/compiler/moduleWithNoValuesAsType.ts(7,8): error TS2708: Cannot use namespace 'B' as a value here because it has no value export. +tests/cases/compiler/moduleWithNoValuesAsType.ts(15,8): error TS2708: Cannot use namespace 'C' as a value here because it has no value export. ==== tests/cases/compiler/moduleWithNoValuesAsType.ts (3 errors) ==== module A { } var a: A; // error ~ -!!! error TS2304: Cannot find name 'A'. +!!! error TS2708: Cannot use namespace 'A' as a value here because it has no value export. module B { interface I {} } var b: B; // error ~ -!!! error TS2304: Cannot find name 'B'. +!!! error TS2708: Cannot use namespace 'B' as a value here because it has no value export. module C { module M { @@ -24,4 +24,4 @@ tests/cases/compiler/moduleWithNoValuesAsType.ts(15,8): error TS2304: Cannot fin var c: C; // error ~ -!!! error TS2304: Cannot find name 'C'. \ No newline at end of file +!!! error TS2708: Cannot use namespace 'C' as a value here because it has no value export. \ No newline at end of file diff --git a/tests/baselines/reference/namespaceModule.errors.txt b/tests/baselines/reference/namespaceModule.errors.txt new file mode 100644 index 00000000000..b23f9621c58 --- /dev/null +++ b/tests/baselines/reference/namespaceModule.errors.txt @@ -0,0 +1,19 @@ +tests/cases/compiler/namespaceModule.ts(3,1): error TS2708: Cannot use namespace 'z' as a value here because it has no value export. +tests/cases/compiler/namespaceModule.ts(9,1): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. + + +==== tests/cases/compiler/namespaceModule.ts (2 errors) ==== + namespace z {} + + z; + ~ +!!! error TS2708: Cannot use namespace 'z' as a value here because it has no value export. + + namespace x { + export type z = string; + } + + x; + ~ +!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. + \ No newline at end of file diff --git a/tests/baselines/reference/namespaceModule.js b/tests/baselines/reference/namespaceModule.js new file mode 100644 index 00000000000..18bf3cf7b22 --- /dev/null +++ b/tests/baselines/reference/namespaceModule.js @@ -0,0 +1,15 @@ +//// [namespaceModule.ts] +namespace z {} + +z; + +namespace x { + export type z = string; +} + +x; + + +//// [namespaceModule.js] +z; +x; diff --git a/tests/baselines/reference/typeUsedAsValueError2.errors.txt b/tests/baselines/reference/typeUsedAsValueError2.errors.txt index 3027abb0e6b..a471055913d 100644 --- a/tests/baselines/reference/typeUsedAsValueError2.errors.txt +++ b/tests/baselines/reference/typeUsedAsValueError2.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/world.ts(4,1): error TS2693: 'HelloInterface' only refers to a type, but is being used as a value here. -tests/cases/compiler/world.ts(5,1): error TS2304: Cannot find name 'HelloNamespace'. +tests/cases/compiler/world.ts(5,1): error TS2708: Cannot use namespace 'HelloNamespace' as a value here because it has no value export. ==== tests/cases/compiler/world.ts (2 errors) ==== @@ -11,7 +11,7 @@ tests/cases/compiler/world.ts(5,1): error TS2304: Cannot find name 'HelloNamespa !!! error TS2693: 'HelloInterface' only refers to a type, but is being used as a value here. HelloNamespace.world; ~~~~~~~~~~~~~~ -!!! error TS2304: Cannot find name 'HelloNamespace'. +!!! error TS2708: Cannot use namespace 'HelloNamespace' as a value here because it has no value export. ==== tests/cases/compiler/helloInterface.ts (0 errors) ==== interface HelloInterface { world: any; diff --git a/tests/baselines/reference/typeofInternalModules.errors.txt b/tests/baselines/reference/typeofInternalModules.errors.txt index c98456c3404..b84e65fe218 100644 --- a/tests/baselines/reference/typeofInternalModules.errors.txt +++ b/tests/baselines/reference/typeofInternalModules.errors.txt @@ -1,8 +1,8 @@ -tests/cases/compiler/typeofInternalModules.ts(15,16): error TS2304: Cannot find name 'importUninst'. +tests/cases/compiler/typeofInternalModules.ts(15,16): error TS2708: Cannot use namespace 'importUninst' as a value here because it has no value export. tests/cases/compiler/typeofInternalModules.ts(17,9): error TS2304: Cannot find name 'Outer'. tests/cases/compiler/typeofInternalModules.ts(19,1): error TS2322: Type 'typeof Outer' is not assignable to type 'typeof instantiated'. Property 'C' is missing in type 'typeof Outer'. -tests/cases/compiler/typeofInternalModules.ts(21,16): error TS2304: Cannot find name 'importUninst'. +tests/cases/compiler/typeofInternalModules.ts(21,16): error TS2708: Cannot use namespace 'importUninst' as a value here because it has no value export. tests/cases/compiler/typeofInternalModules.ts(23,1): error TS2322: Type 'typeof instantiated' is not assignable to type 'typeof Outer'. Property 'instantiated' is missing in type 'typeof instantiated'. @@ -24,7 +24,7 @@ tests/cases/compiler/typeofInternalModules.ts(23,1): error TS2322: Type 'typeof var x2: importInst.C = new x1(); var x3: typeof importUninst.P; // Error again ~~~~~~~~~~~~ -!!! error TS2304: Cannot find name 'importUninst'. +!!! error TS2708: Cannot use namespace 'importUninst' as a value here because it has no value export. var x4: Outer = Outer; ~~~~~ @@ -37,7 +37,7 @@ tests/cases/compiler/typeofInternalModules.ts(23,1): error TS2322: Type 'typeof x5 = Outer.instantiated; var x6: typeof importUninst; ~~~~~~~~~~~~ -!!! error TS2304: Cannot find name 'importUninst'. +!!! error TS2708: Cannot use namespace 'importUninst' as a value here because it has no value export. var x7: typeof Outer = Outer; x7 = importInst; ~~ diff --git a/tests/cases/compiler/namespaceModule.ts b/tests/cases/compiler/namespaceModule.ts new file mode 100644 index 00000000000..a1ad71d96a0 --- /dev/null +++ b/tests/cases/compiler/namespaceModule.ts @@ -0,0 +1,9 @@ +namespace z {} + +z; + +namespace x { + export type z = string; +} + +x; From 5496096ee36c4305007639df424ab9f04d4ea1ab Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Thu, 13 Apr 2017 10:29:32 -0700 Subject: [PATCH 23/35] Split addPrologue into string + custom directives The original function is now named addPrologue. There are then three places than need to call the two split functions separately. --- src/compiler/factory.ts | 27 ++++++++++++++++++++-- src/compiler/transformers/es2015.ts | 22 +++++++++++++----- src/compiler/transformers/es2017.ts | 2 +- src/compiler/transformers/esnext.ts | 15 ++++++++---- src/compiler/transformers/generators.ts | 2 +- src/compiler/transformers/module/es2015.ts | 2 +- src/compiler/transformers/module/module.ts | 4 ++-- src/compiler/transformers/module/system.ts | 2 +- src/compiler/transformers/ts.ts | 2 +- 9 files changed, 59 insertions(+), 19 deletions(-) diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts index 5a4c4c032ee..a945f7c7c10 100644 --- a/src/compiler/factory.ts +++ b/src/compiler/factory.ts @@ -3058,14 +3058,26 @@ namespace ts { * @param ensureUseStrict: boolean determining whether the function need to add prologue-directives * @param visitor: Optional callback used to visit any custom prologue directives. */ - export function addPrologueDirectives(target: Statement[], source: Statement[], ensureUseStrict?: boolean, visitor?: (node: Node) => VisitResult): number { + export function addPrologue(target: Statement[], source: Statement[], ensureUseStrict?: boolean, visitor?: (node: Node) => VisitResult): number { + const offset = addPrologueDirectives(target, source, ensureUseStrict); + return addCustomPrologue(target, source, offset, visitor); + } + + /** + * Add just the standard (string-expression) prologue-directives into target statement-array. + * The function needs to be called during each transformation step. + * This function needs to be called whenever we transform the statement + * list of a source file, namespace, or function-like body. + */ + export function addPrologueDirectives(target: Statement[], source: Statement[], ensureUseStrict?: boolean): number { + Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array"); let foundUseStrict = false; let statementOffset = 0; const numStatements = source.length; while (statementOffset < numStatements) { const statement = source[statementOffset]; if (isPrologueDirective(statement)) { - if (isUseStrictPrologue(statement as ExpressionStatement)) { + if (isUseStrictPrologue(statement)) { foundUseStrict = true; } target.push(statement); @@ -3078,6 +3090,17 @@ namespace ts { if (ensureUseStrict && !foundUseStrict) { target.push(startOnNewLine(createStatement(createLiteral("use strict")))); } + return statementOffset; + } + + /** + * Add just the custom prologue-directives into target statement-array. + * The function needs to be called during each transformation step. + * This function needs to be called whenever we transform the statement + * list of a source file, namespace, or function-like body. + */ + export function addCustomPrologue(target: Statement[], source: Statement[], statementOffset: number, visitor?: (node: Node) => VisitResult): number { + const numStatements = source.length; while (statementOffset < numStatements) { const statement = source[statementOffset]; if (getEmitFlags(statement) & EmitFlags.CustomPrologue) { diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts index 3675571b720..897a4a57502 100644 --- a/src/compiler/transformers/es2015.ts +++ b/src/compiler/transformers/es2015.ts @@ -515,8 +515,9 @@ namespace ts { const ancestorFacts = enterSubtree(HierarchyFacts.SourceFileExcludes, HierarchyFacts.SourceFileIncludes); const statements: Statement[] = []; startLexicalEnvironment(); + let statementOffset = addPrologueDirectives(statements, node.statements, /*ensureUseStrict*/ false); addCaptureThisForNodeIfNeeded(statements, node); - const statementOffset = addPrologueDirectives(statements, node.statements, /*ensureUseStrict*/ false, visitor); + statementOffset = addCustomPrologue(statements, node.statements, statementOffset, visitor); addRange(statements, visitNodes(node.statements, visitor, isStatement, statementOffset)); addRange(statements, endLexicalEnvironment()); exitSubtree(ancestorFacts, HierarchyFacts.None, HierarchyFacts.None); @@ -923,13 +924,16 @@ namespace ts { // The assumption is that no prior step in the pipeline has added any prologue directives. statementOffset = 0; } + else if (constructor) { + statementOffset = addPrologueDirectives(statements, constructor.body.statements, /*ensureUseStrict*/ false); + } if (constructor) { addDefaultValueAssignmentsIfNeeded(statements, constructor); addRestParameterIfNeeded(statements, constructor, hasSynthesizedSuper); if (!hasSynthesizedSuper) { - // If no super call has been synthesized, try to emit all potential prologue directives. - statementOffset = addPrologueDirectives(statements, constructor.body.statements, /*ensureUseStrict*/ false, visitor); + // If no super call has been synthesized, emit custom prologue directives. + statementOffset = addCustomPrologue(statements, constructor.body.statements, statementOffset, visitor); } Debug.assert(statementOffset >= 0, "statementOffset not initialized correctly!"); @@ -1816,8 +1820,15 @@ namespace ts { const statements: Statement[] = []; const body = node.body; + let statementOffset: number; resumeLexicalEnvironment(); + if (isBlock(body)) { + // ensureUseStrict is false because no new prologue-directive should be added. + // addPrologueDirectives will put already-existing directives at the beginning of the target statement-array + statementOffset = addPrologueDirectives(statements, body.statements, /*ensureUseStrict*/ false); + } + addCaptureThisForNodeIfNeeded(statements, node); addDefaultValueAssignmentsIfNeeded(statements, node); addRestParameterIfNeeded(statements, node, /*inConstructorWithSynthesizedSuper*/ false); @@ -1828,9 +1839,8 @@ namespace ts { } if (isBlock(body)) { - // ensureUseStrict is false because no new prologue-directive should be added. - // addPrologueDirectives will simply put already-existing directives at the beginning of the target statement-array - const statementOffset = addPrologueDirectives(statements, body.statements, /*ensureUseStrict*/ false, visitor); + // addCustomPrologue puts already-existing directives at the beginning of the target statement-array + statementOffset = addCustomPrologue(statements, body.statements, statementOffset, visitor); statementsLocation = body.statements; addRange(statements, visitNodes(body.statements, visitor, isStatement, statementOffset)); diff --git a/src/compiler/transformers/es2017.ts b/src/compiler/transformers/es2017.ts index 088c57866d0..3bbb3b3123f 100644 --- a/src/compiler/transformers/es2017.ts +++ b/src/compiler/transformers/es2017.ts @@ -222,7 +222,7 @@ namespace ts { if (!isArrowFunction) { const statements: Statement[] = []; - const statementOffset = addPrologueDirectives(statements, (node.body).statements, /*ensureUseStrict*/ false, visitor); + const statementOffset = addPrologue(statements, (node.body).statements, /*ensureUseStrict*/ false, visitor); statements.push( createReturn( createAwaiterHelper( diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index 83e84e6eab5..b0e8b527820 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -618,7 +618,7 @@ namespace ts { function transformAsyncGeneratorFunctionBody(node: MethodDeclaration | AccessorDeclaration | FunctionDeclaration | FunctionExpression): FunctionBody { resumeLexicalEnvironment(); const statements: Statement[] = []; - const statementOffset = addPrologueDirectives(statements, node.body.statements, /*ensureUseStrict*/ false, visitor); + const statementOffset = addPrologue(statements, node.body.statements, /*ensureUseStrict*/ false, visitor); appendObjectRestAssignmentsIfNeeded(statements, node); statements.push( @@ -663,12 +663,19 @@ namespace ts { function transformFunctionBody(node: ArrowFunction): ConciseBody; function transformFunctionBody(node: FunctionLikeDeclaration): ConciseBody { resumeLexicalEnvironment(); - const leadingStatements = appendObjectRestAssignmentsIfNeeded(/*statements*/ undefined, node); + let statementOffset = 0; + const statements: Statement[] = []; const body = visitNode(node.body, visitor, isConciseBody); + if (isBlock(body)) { + statementOffset = addPrologue(statements, body.statements, /*ensureUseStrict*/ false, visitor); + } + addRange(statements, appendObjectRestAssignmentsIfNeeded(/*statements*/ undefined, node)); const trailingStatements = endLexicalEnvironment(); - if (some(leadingStatements) || some(trailingStatements)) { + if (statementOffset > 0 || some(statements) || some(trailingStatements)) { const block = convertToFunctionBody(body, /*multiLine*/ true); - return updateBlock(block, setTextRange(createNodeArray(concatenate(concatenate(leadingStatements, block.statements), trailingStatements)), block.statements)); + addRange(statements, block.statements.slice(statementOffset)); + addRange(statements, trailingStatements); + return updateBlock(block, setTextRange(createNodeArray(statements), block.statements)); } return body; } diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts index d2f2162f455..3b361b1d524 100644 --- a/src/compiler/transformers/generators.ts +++ b/src/compiler/transformers/generators.ts @@ -587,7 +587,7 @@ namespace ts { // Build the generator resumeLexicalEnvironment(); - const statementOffset = addPrologueDirectives(statements, body.statements, /*ensureUseStrict*/ false, visitor); + const statementOffset = addPrologue(statements, body.statements, /*ensureUseStrict*/ false, visitor); transformAndEmitStatements(body.statements, statementOffset); diff --git a/src/compiler/transformers/module/es2015.ts b/src/compiler/transformers/module/es2015.ts index 7028e235961..660293e074f 100644 --- a/src/compiler/transformers/module/es2015.ts +++ b/src/compiler/transformers/module/es2015.ts @@ -24,7 +24,7 @@ namespace ts { const externalHelpersModuleName = getOrCreateExternalHelpersModuleNameIfNeeded(node, compilerOptions); if (externalHelpersModuleName) { const statements: Statement[] = []; - const statementOffset = addPrologueDirectives(statements, node.statements); + const statementOffset = addPrologue(statements, node.statements); append(statements, createImportDeclaration( /*decorators*/ undefined, diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts index 4fe7b027e93..d387a1a3a24 100644 --- a/src/compiler/transformers/module/module.ts +++ b/src/compiler/transformers/module/module.ts @@ -90,7 +90,7 @@ namespace ts { const statements: Statement[] = []; const ensureUseStrict = compilerOptions.alwaysStrict || (!compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile)); - const statementOffset = addPrologueDirectives(statements, node.statements, ensureUseStrict, sourceElementVisitor); + const statementOffset = addPrologue(statements, node.statements, ensureUseStrict, sourceElementVisitor); if (shouldEmitUnderscoreUnderscoreESModule()) { append(statements, createUnderscoreUnderscoreESModule()); @@ -388,7 +388,7 @@ namespace ts { startLexicalEnvironment(); const statements: Statement[] = []; - const statementOffset = addPrologueDirectives(statements, node.statements, /*ensureUseStrict*/ !compilerOptions.noImplicitUseStrict, sourceElementVisitor); + const statementOffset = addPrologue(statements, node.statements, /*ensureUseStrict*/ !compilerOptions.noImplicitUseStrict, sourceElementVisitor); if (shouldEmitUnderscoreUnderscoreESModule()) { append(statements, createUnderscoreUnderscoreESModule()); diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts index 56341f482ff..cde4fcad57e 100644 --- a/src/compiler/transformers/module/system.ts +++ b/src/compiler/transformers/module/system.ts @@ -228,7 +228,7 @@ namespace ts { // Add any prologue directives. const ensureUseStrict = compilerOptions.alwaysStrict || (!compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile)); - const statementOffset = addPrologueDirectives(statements, node.statements, ensureUseStrict, sourceElementVisitor); + const statementOffset = addPrologue(statements, node.statements, ensureUseStrict, sourceElementVisitor); // var __moduleName = context_1 && context_1.id; statements.push( diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 8df760d51c0..0daf76fa9ec 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -954,7 +954,7 @@ namespace ts { if (ctor.body) { const statements = ctor.body.statements; // add prologue directives to the list (if any) - const index = addPrologueDirectives(result, statements, /*ensureUseStrict*/ false, visitor); + const index = addPrologue(result, statements, /*ensureUseStrict*/ false, visitor); if (index === statements.length) { // list contains nothing but prologue directives (or empty) - exit return index; From b2199bd23c98bc4cb29024c9c93f4c62166ef671 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Thu, 13 Apr 2017 10:35:50 -0700 Subject: [PATCH 24/35] Test:order of directives, initialisers, object spread destructuring --- ...meterInitializerBeforeDestructuringEmit.js | 49 ++++++++++++++++ ...InitializerBeforeDestructuringEmit.symbols | 44 ++++++++++++++ ...erInitializerBeforeDestructuringEmit.types | 58 +++++++++++++++++++ ...meterInitializerBeforeDestructuringEmit.ts | 20 +++++++ 4 files changed, 171 insertions(+) create mode 100644 tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.js create mode 100644 tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.symbols create mode 100644 tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.types create mode 100644 tests/cases/compiler/parameterInitializerBeforeDestructuringEmit.ts diff --git a/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.js b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.js new file mode 100644 index 00000000000..e7d4a4472e8 --- /dev/null +++ b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.js @@ -0,0 +1,49 @@ +//// [parameterInitializerBeforeDestructuringEmit.ts] +interface Foo { + bar?: any; + baz?: any; +} + +function foobar({ bar = {}, ...opts }: Foo = {}) { + "use strict"; + "Some other prologue"; + opts.baz(bar); +} + +class C { + constructor({ bar = {}, ...opts }: Foo = {}) { + "use strict"; + "Some other prologue"; + opts.baz(bar); + } +} + + +//// [parameterInitializerBeforeDestructuringEmit.js] +"use strict"; +var __rest = (this && this.__rest) || function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0) + t[p[i]] = s[p[i]]; + return t; +}; +function foobar(_a) { + "use strict"; + "Some other prologue"; + if (_a === void 0) { _a = {}; } + var _b = _a.bar, bar = _b === void 0 ? {} : _b, opts = __rest(_a, ["bar"]); + opts.baz(bar); +} +var C = (function () { + function C(_a) { + "use strict"; + "Some other prologue"; + if (_a === void 0) { _a = {}; } + var _b = _a.bar, bar = _b === void 0 ? {} : _b, opts = __rest(_a, ["bar"]); + opts.baz(bar); + } + return C; +}()); diff --git a/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.symbols b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.symbols new file mode 100644 index 00000000000..857310bf87c --- /dev/null +++ b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.symbols @@ -0,0 +1,44 @@ +=== tests/cases/compiler/parameterInitializerBeforeDestructuringEmit.ts === +interface Foo { +>Foo : Symbol(Foo, Decl(parameterInitializerBeforeDestructuringEmit.ts, 0, 0)) + + bar?: any; +>bar : Symbol(Foo.bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 0, 15)) + + baz?: any; +>baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14)) +} + +function foobar({ bar = {}, ...opts }: Foo = {}) { +>foobar : Symbol(foobar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 3, 1)) +>bar : Symbol(bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 5, 17)) +>opts : Symbol(opts, Decl(parameterInitializerBeforeDestructuringEmit.ts, 5, 27)) +>Foo : Symbol(Foo, Decl(parameterInitializerBeforeDestructuringEmit.ts, 0, 0)) + + "use strict"; + "Some other prologue"; + opts.baz(bar); +>opts.baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14)) +>opts : Symbol(opts, Decl(parameterInitializerBeforeDestructuringEmit.ts, 5, 27)) +>baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14)) +>bar : Symbol(bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 5, 17)) +} + +class C { +>C : Symbol(C, Decl(parameterInitializerBeforeDestructuringEmit.ts, 9, 1)) + + constructor({ bar = {}, ...opts }: Foo = {}) { +>bar : Symbol(bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 12, 17)) +>opts : Symbol(opts, Decl(parameterInitializerBeforeDestructuringEmit.ts, 12, 27)) +>Foo : Symbol(Foo, Decl(parameterInitializerBeforeDestructuringEmit.ts, 0, 0)) + + "use strict"; + "Some other prologue"; + opts.baz(bar); +>opts.baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14)) +>opts : Symbol(opts, Decl(parameterInitializerBeforeDestructuringEmit.ts, 12, 27)) +>baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14)) +>bar : Symbol(bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 12, 17)) + } +} + diff --git a/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.types b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.types new file mode 100644 index 00000000000..46b5983a514 --- /dev/null +++ b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.types @@ -0,0 +1,58 @@ +=== tests/cases/compiler/parameterInitializerBeforeDestructuringEmit.ts === +interface Foo { +>Foo : Foo + + bar?: any; +>bar : any + + baz?: any; +>baz : any +} + +function foobar({ bar = {}, ...opts }: Foo = {}) { +>foobar : ({bar, ...opts}?: Foo) => void +>bar : any +>{} : {} +>opts : { baz?: any; } +>Foo : Foo +>{} : {} + + "use strict"; +>"use strict" : "use strict" + + "Some other prologue"; +>"Some other prologue" : "Some other prologue" + + opts.baz(bar); +>opts.baz(bar) : any +>opts.baz : any +>opts : { baz?: any; } +>baz : any +>bar : any +} + +class C { +>C : C + + constructor({ bar = {}, ...opts }: Foo = {}) { +>bar : any +>{} : {} +>opts : { baz?: any; } +>Foo : Foo +>{} : {} + + "use strict"; +>"use strict" : "use strict" + + "Some other prologue"; +>"Some other prologue" : "Some other prologue" + + opts.baz(bar); +>opts.baz(bar) : any +>opts.baz : any +>opts : { baz?: any; } +>baz : any +>bar : any + } +} + diff --git a/tests/cases/compiler/parameterInitializerBeforeDestructuringEmit.ts b/tests/cases/compiler/parameterInitializerBeforeDestructuringEmit.ts new file mode 100644 index 00000000000..461ab1b9cf8 --- /dev/null +++ b/tests/cases/compiler/parameterInitializerBeforeDestructuringEmit.ts @@ -0,0 +1,20 @@ +// @noImplicitUseStrict: false +// @alwaysStrict: true +interface Foo { + bar?: any; + baz?: any; +} + +function foobar({ bar = {}, ...opts }: Foo = {}) { + "use strict"; + "Some other prologue"; + opts.baz(bar); +} + +class C { + constructor({ bar = {}, ...opts }: Foo = {}) { + "use strict"; + "Some other prologue"; + opts.baz(bar); + } +} From 58a6c92c297a7bb9da2d9e57c8440993b74ff3e8 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Thu, 13 Apr 2017 13:21:56 -0700 Subject: [PATCH 25/35] Rename addPrologueDirectives->addStandardPrologue --- src/compiler/factory.ts | 4 ++-- src/compiler/transformers/es2015.ts | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts index a945f7c7c10..5c7486debe3 100644 --- a/src/compiler/factory.ts +++ b/src/compiler/factory.ts @@ -3059,7 +3059,7 @@ namespace ts { * @param visitor: Optional callback used to visit any custom prologue directives. */ export function addPrologue(target: Statement[], source: Statement[], ensureUseStrict?: boolean, visitor?: (node: Node) => VisitResult): number { - const offset = addPrologueDirectives(target, source, ensureUseStrict); + const offset = addStandardPrologue(target, source, ensureUseStrict); return addCustomPrologue(target, source, offset, visitor); } @@ -3069,7 +3069,7 @@ namespace ts { * This function needs to be called whenever we transform the statement * list of a source file, namespace, or function-like body. */ - export function addPrologueDirectives(target: Statement[], source: Statement[], ensureUseStrict?: boolean): number { + export function addStandardPrologue(target: Statement[], source: Statement[], ensureUseStrict?: boolean): number { Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array"); let foundUseStrict = false; let statementOffset = 0; diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts index 897a4a57502..83ed1df164a 100644 --- a/src/compiler/transformers/es2015.ts +++ b/src/compiler/transformers/es2015.ts @@ -515,7 +515,7 @@ namespace ts { const ancestorFacts = enterSubtree(HierarchyFacts.SourceFileExcludes, HierarchyFacts.SourceFileIncludes); const statements: Statement[] = []; startLexicalEnvironment(); - let statementOffset = addPrologueDirectives(statements, node.statements, /*ensureUseStrict*/ false); + let statementOffset = addStandardPrologue(statements, node.statements, /*ensureUseStrict*/ false); addCaptureThisForNodeIfNeeded(statements, node); statementOffset = addCustomPrologue(statements, node.statements, statementOffset, visitor); addRange(statements, visitNodes(node.statements, visitor, isStatement, statementOffset)); @@ -925,7 +925,7 @@ namespace ts { statementOffset = 0; } else if (constructor) { - statementOffset = addPrologueDirectives(statements, constructor.body.statements, /*ensureUseStrict*/ false); + statementOffset = addStandardPrologue(statements, constructor.body.statements, /*ensureUseStrict*/ false); } if (constructor) { @@ -1825,8 +1825,8 @@ namespace ts { resumeLexicalEnvironment(); if (isBlock(body)) { // ensureUseStrict is false because no new prologue-directive should be added. - // addPrologueDirectives will put already-existing directives at the beginning of the target statement-array - statementOffset = addPrologueDirectives(statements, body.statements, /*ensureUseStrict*/ false); + // addStandardPrologue will put already-existing directives at the beginning of the target statement-array + statementOffset = addStandardPrologue(statements, body.statements, /*ensureUseStrict*/ false); } addCaptureThisForNodeIfNeeded(statements, node); From ea9670de43e18da781cc4394719608f6d2fe2f1d Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Thu, 13 Apr 2017 14:57:25 -0700 Subject: [PATCH 26/35] Port generated lib files --- src/lib/dom.generated.d.ts | 320 ++++++++++++++++++++----------- src/lib/webworker.generated.d.ts | 161 ++++++++++++---- 2 files changed, 334 insertions(+), 147 deletions(-) diff --git a/src/lib/dom.generated.d.ts b/src/lib/dom.generated.d.ts index 348e52246a7..c43c59e3b12 100644 --- a/src/lib/dom.generated.d.ts +++ b/src/lib/dom.generated.d.ts @@ -78,8 +78,8 @@ interface ConstrainLongRange extends LongRange { } interface ConstrainVideoFacingModeParameters { - exact?: string | string[]; - ideal?: string | string[]; + exact?: VideoFacingModeEnum | VideoFacingModeEnum[]; + ideal?: VideoFacingModeEnum | VideoFacingModeEnum[]; } interface CustomEventInit extends EventInit { @@ -308,7 +308,7 @@ interface MSAudioSendSignal { } interface MSConnectivity { - iceType?: string; + iceType?: MSIceType; iceWarningFlags?: MSIceWarningFlags; relayAddress?: MSRelayAddress; } @@ -318,11 +318,11 @@ interface MSCredentialFilter { } interface MSCredentialParameters { - type?: string; + type?: MSCredentialType; } interface MSCredentialSpec { - type?: string; + type?: MSCredentialType; id?: string; } @@ -333,7 +333,7 @@ interface MSDelay { interface MSDescription extends RTCStats { connectivity?: MSConnectivity; - transport?: string; + transport?: RTCIceProtocol; networkconnectivity?: MSNetworkConnectivityInfo; localAddr?: MSIPAddressInfo; remoteAddr?: MSIPAddressInfo; @@ -457,11 +457,11 @@ interface MSTransportDiagnosticsStats extends RTCStats { numConsentRespReceived?: number; interfaces?: MSNetworkInterfaceType; baseInterface?: MSNetworkInterfaceType; - protocol?: string; + protocol?: RTCIceProtocol; localInterface?: MSNetworkInterfaceType; - localAddrType?: string; - remoteAddrType?: string; - iceRole?: string; + localAddrType?: MSIceAddrType; + remoteAddrType?: MSIceAddrType; + iceRole?: RTCIceRole; rtpRtcpMux?: boolean; allocationTimeInMs?: number; msRtcEngineVersion?: string; @@ -534,7 +534,7 @@ interface MediaEncryptedEventInit extends EventInit { } interface MediaKeyMessageEventInit extends EventInit { - messageType?: string; + messageType?: MediaKeyMessageType; message?: ArrayBuffer; } @@ -542,8 +542,8 @@ interface MediaKeySystemConfiguration { initDataTypes?: string[]; audioCapabilities?: MediaKeySystemMediaCapability[]; videoCapabilities?: MediaKeySystemMediaCapability[]; - distinctiveIdentifier?: string; - persistentState?: string; + distinctiveIdentifier?: MediaKeysRequirement; + persistentState?: MediaKeysRequirement; } interface MediaKeySystemMediaCapability { @@ -667,7 +667,7 @@ interface MutationObserverInit { } interface NotificationOptions { - dir?: string; + dir?: NotificationDirection; lang?: string; body?: string; tag?: string; @@ -766,8 +766,8 @@ interface PushSubscriptionOptionsInit { interface RTCConfiguration { iceServers?: RTCIceServer[]; - iceTransportPolicy?: string; - bundlePolicy?: string; + iceTransportPolicy?: RTCIceTransportPolicy; + bundlePolicy?: RTCBundlePolicy; peerIdentity?: string; } @@ -781,7 +781,7 @@ interface RTCDtlsFingerprint { } interface RTCDtlsParameters { - role?: string; + role?: RTCDtlsRole; fingerprints?: RTCDtlsFingerprint[]; } @@ -789,7 +789,7 @@ interface RTCIceCandidateAttributes extends RTCStats { ipAddress?: string; portNumber?: number; transport?: string; - candidateType?: string; + candidateType?: RTCStatsIceCandidateType; priority?: number; addressSourceUrl?: string; } @@ -801,10 +801,10 @@ interface RTCIceCandidateDictionary { foundation?: string; priority?: number; ip?: string; - protocol?: string; + protocol?: RTCIceProtocol; port?: number; - type?: string; - tcpType?: string; + type?: RTCIceCandidateType; + tcpType?: RTCIceTcpCandidateType; relatedAddress?: string; relatedPort?: number; msMTurnSessionId?: string; @@ -825,7 +825,7 @@ interface RTCIceCandidatePairStats extends RTCStats { transportId?: string; localCandidateId?: string; remoteCandidateId?: string; - state?: string; + state?: RTCStatsIceCandidatePairState; priority?: number; nominated?: boolean; writable?: boolean; @@ -838,7 +838,7 @@ interface RTCIceCandidatePairStats extends RTCStats { } interface RTCIceGatherOptions { - gatherPolicy?: string; + gatherPolicy?: RTCIceGatherPolicy; iceservers?: RTCIceServer[]; portRange?: MSPortRange; } @@ -1003,7 +1003,7 @@ interface RTCRtpParameters { headerExtensions?: RTCRtpHeaderExtensionParameters[]; encodings?: RTCRtpEncodingParameters[]; rtcp?: RTCRtcpParameters; - degradationPreference?: string; + degradationPreference?: RTCDegradationPreference; } interface RTCRtpRtxParameters { @@ -1017,7 +1017,7 @@ interface RTCRtpUnhandled { } interface RTCSessionDescriptionInit { - type?: string; + type?: RTCSdpType; sdp?: string; } @@ -1043,9 +1043,9 @@ interface RTCSsrcRange { interface RTCStats { timestamp?: number; - type?: string; + type?: RTCStatsType; id?: string; - msType?: string; + msType?: MSStatsType; } interface RTCStatsReport { @@ -1070,11 +1070,11 @@ interface RequestInit { headers?: any; body?: any; referrer?: string; - referrerPolicy?: string; - mode?: string; - credentials?: string; - cache?: string; - redirect?: string; + referrerPolicy?: ReferrerPolicy; + mode?: RequestMode; + credentials?: RequestCredentials; + cache?: RequestCache; + redirect?: RequestRedirect; integrity?: string; keepalive?: boolean; window?: any; @@ -1087,9 +1087,9 @@ interface ResponseInit { } interface ScopedCredentialDescriptor { - type?: string; + type?: ScopedCredentialType; id?: any; - transports?: string[]; + transports?: Transport[]; } interface ScopedCredentialOptions { @@ -1100,7 +1100,7 @@ interface ScopedCredentialOptions { } interface ScopedCredentialParameters { - type?: string; + type?: ScopedCredentialType; algorithm?: string | Algorithm; } @@ -1330,7 +1330,7 @@ interface AudioContextBase extends EventTarget { readonly listener: AudioListener; onstatechange: (this: AudioContext, ev: Event) => any; readonly sampleRate: number; - readonly state: string; + readonly state: AudioContextState; close(): Promise; createAnalyser(): AnalyserNode; createBiquadFilter(): BiquadFilterNode; @@ -1390,8 +1390,8 @@ declare var AudioListener: { interface AudioNode extends EventTarget { channelCount: number; - channelCountMode: string; - channelInterpretation: string; + channelCountMode: ChannelCountMode; + channelInterpretation: ChannelInterpretation; readonly context: AudioContext; readonly numberOfInputs: number; readonly numberOfOutputs: number; @@ -1494,7 +1494,7 @@ interface BiquadFilterNode extends AudioNode { readonly detune: AudioParam; readonly frequency: AudioParam; readonly gain: AudioParam; - type: string; + type: BiquadFilterType; getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void; } @@ -2134,7 +2134,7 @@ interface CanvasRenderingContext2D extends Object, CanvasPathMethods { lineJoin: string; lineWidth: number; miterLimit: number; - msFillRule: string; + msFillRule: CanvasFillRule; shadowBlur: number; shadowColor: string; shadowOffsetX: number; @@ -2147,7 +2147,7 @@ interface CanvasRenderingContext2D extends Object, CanvasPathMethods { oImageSmoothingEnabled: boolean; beginPath(): void; clearRect(x: number, y: number, w: number, h: number): void; - clip(fillRule?: string): void; + clip(fillRule?: CanvasFillRule): void; createImageData(imageDataOrSw: number | ImageData, sh?: number): ImageData; createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient; createPattern(image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement, repetition: string): CanvasPattern; @@ -2156,12 +2156,12 @@ interface CanvasRenderingContext2D extends Object, CanvasPathMethods { drawImage(image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap, dstX: number, dstY: number): void; drawImage(image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap, dstX: number, dstY: number, dstW: number, dstH: number): void; drawImage(image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap, srcX: number, srcY: number, srcW: number, srcH: number, dstX: number, dstY: number, dstW: number, dstH: number): void; - fill(fillRule?: string): void; + fill(fillRule?: CanvasFillRule): void; fillRect(x: number, y: number, w: number, h: number): void; fillText(text: string, x: number, y: number, maxWidth?: number): void; getImageData(sx: number, sy: number, sw: number, sh: number): ImageData; getLineDash(): number[]; - isPointInPath(x: number, y: number, fillRule?: string): boolean; + isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean; measureText(text: string): TextMetrics; putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX?: number, dirtyY?: number, dirtyWidth?: number, dirtyHeight?: number): void; restore(): void; @@ -2538,6 +2538,7 @@ interface DataTransfer { clearData(format?: string): boolean; getData(format: string): string; setData(format: string, data: string): boolean; + setDragImage(image: Element, x: number, y: number): void; } declare var DataTransfer: { @@ -2574,7 +2575,7 @@ declare var DataTransferItemList: { interface DeferredPermissionRequest { readonly id: number; - readonly type: string; + readonly type: MSWebViewPermissionType; readonly uri: string; allow(): void; deny(): void; @@ -3192,7 +3193,7 @@ interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEven * Contains the title of the document. */ title: string; - readonly visibilityState: string; + readonly visibilityState: VisibilityState; /** * Sets or gets the color of the links that the user has visited. */ @@ -3207,7 +3208,7 @@ interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEven * Gets or sets the version attribute specified in the declaration of an XML document. */ xmlVersion: string | null; - adoptNode(source: Node): Node; + adoptNode(source: T): T; captureEvents(): void; caretRangeFromPoint(x: number, y: number): Range; clear(): void; @@ -3384,7 +3385,7 @@ interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEven * Gets a value indicating whether the object currently has focus. */ hasFocus(): boolean; - importNode(importedNode: Node, deep: boolean): Node; + importNode(importedNode: T, deep: boolean): T; msElementsFromPoint(x: number, y: number): NodeListOf; msElementsFromRect(left: number, top: number, width: number, height: number): NodeListOf; /** @@ -3700,9 +3701,9 @@ declare var Event: { } interface EventTarget { - addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void; + addEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; dispatchEvent(evt: Event): boolean; - removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void; + removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } declare var EventTarget: { @@ -3781,7 +3782,7 @@ declare var FocusEvent: { } interface FocusNavigationEvent extends Event { - readonly navigationReason: string; + readonly navigationReason: NavigationReason; readonly originHeight: number; readonly originLeft: number; readonly originTop: number; @@ -3795,7 +3796,12 @@ declare var FocusNavigationEvent: { } interface FormData { - append(name: any, value: any, blobName?: string): void; + append(name: string, value: string | Blob, fileName?: string): void; + delete(name: string): void; + get(name: string): FormDataEntryValue | null; + getAll(name: string): FormDataEntryValue[]; + has(name: string): boolean; + set(name: string, value: string | Blob, fileName?: string): void; } declare var FormData: { @@ -6957,7 +6963,7 @@ declare var History: { } interface IDBCursor { - readonly direction: string; + readonly direction: IDBCursorDirection; key: IDBKeyRange | IDBValidKey; readonly primaryKey: any; source: IDBObjectStore | IDBIndex; @@ -7109,7 +7115,7 @@ interface IDBRequest extends EventTarget { readonly error: DOMError; onerror: (this: IDBRequest, ev: Event) => any; onsuccess: (this: IDBRequest, ev: Event) => any; - readonly readyState: string; + readonly readyState: IDBRequestReadyState; readonly result: any; source: IDBObjectStore | IDBIndex | IDBCursor; readonly transaction: IDBTransaction; @@ -7131,7 +7137,7 @@ interface IDBTransactionEventMap { interface IDBTransaction extends EventTarget { readonly db: IDBDatabase; readonly error: DOMError; - readonly mode: string; + readonly mode: IDBTransactionMode; onabort: (this: IDBTransaction, ev: Event) => any; oncomplete: (this: IDBTransaction, ev: Event) => any; onerror: (this: IDBTransaction, ev: Event) => any; @@ -7249,7 +7255,7 @@ declare var KeyboardEvent: { interface ListeningStateChangedEvent extends Event { readonly label: string; - readonly state: string; + readonly state: ListeningState; } declare var ListeningStateChangedEvent: { @@ -7340,7 +7346,7 @@ declare var MSAppAsyncOperation: { interface MSAssertion { readonly id: string; - readonly type: string; + readonly type: MSCredentialType; } declare var MSAssertion: { @@ -7372,7 +7378,7 @@ interface MSFIDOCredentialAssertion extends MSAssertion { readonly algorithm: string | Algorithm; readonly attestation: any; readonly publicKey: string; - readonly transportHints: string[]; + readonly transportHints: MSTransportType[]; } declare var MSFIDOCredentialAssertion: { @@ -7476,7 +7482,7 @@ interface MSHTMLWebViewElement extends HTMLElement { goForward(): void; invokeScriptAsync(scriptName: string, ...args: any[]): MSWebViewAsyncOperation; navigate(uri: string): void; - navigateFocus(navigationReason: string, origin: FocusNavigationOrigin): void; + navigateFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void; navigateToLocalStreamUri(source: string, streamResolver: any): void; navigateToString(contents: string): void; navigateWithHttpRequestMessage(requestMessage: any): void; @@ -7731,7 +7737,7 @@ declare var MSWebViewSettings: { interface MediaDeviceInfo { readonly deviceId: string; readonly groupId: string; - readonly kind: string; + readonly kind: MediaDeviceKind; readonly label: string; } @@ -7798,7 +7804,7 @@ declare var MediaError: { interface MediaKeyMessageEvent extends Event { readonly message: ArrayBuffer; - readonly messageType: string; + readonly messageType: MediaKeyMessageType; } declare var MediaKeyMessageEvent: { @@ -7826,7 +7832,7 @@ declare var MediaKeySession: { interface MediaKeyStatusMap { readonly size: number; forEach(callback: ForEachCallback): void; - get(keyId: any): string; + get(keyId: any): MediaKeyStatus; has(keyId: any): boolean; } @@ -7847,7 +7853,7 @@ declare var MediaKeySystemAccess: { } interface MediaKeys { - createSession(sessionType?: string): MediaKeySession; + createSession(sessionType?: MediaKeySessionType): MediaKeySession; setServerCertificate(serverCertificate: any): Promise; } @@ -7985,7 +7991,7 @@ interface MediaStreamTrack extends EventTarget { onoverconstrained: (this: MediaStreamTrack, ev: MediaStreamErrorEvent) => any; onunmute: (this: MediaStreamTrack, ev: Event) => any; readonly readonly: boolean; - readonly readyState: string; + readonly readyState: MediaStreamTrackState; readonly remote: boolean; applyConstraints(constraints: MediaTrackConstraints): Promise; clone(): MediaStreamTrack; @@ -8206,7 +8212,7 @@ declare var NavigationEventWithReferrer: { interface Navigator extends Object, NavigatorID, NavigatorOnLine, NavigatorContentUtils, NavigatorStorageUtils, NavigatorGeolocation, MSNavigatorDoNotTrack, MSFileSaver, NavigatorBeacon, NavigatorConcurrentHardware, NavigatorUserMedia { readonly authentication: WebAuthentication; readonly cookieEnabled: boolean; - gamepadInputEmulation: string; + gamepadInputEmulation: GamepadInputEmulationType; readonly language: string; readonly maxTouchPoints: number; readonly mimeTypes: MimeTypeArray; @@ -8253,15 +8259,15 @@ interface Node extends EventTarget { contains(child: Node): boolean; hasAttributes(): boolean; hasChildNodes(): boolean; - insertBefore(newChild: Node, refChild: Node | null): Node; + insertBefore(newChild: T, refChild: Node | null): T; isDefaultNamespace(namespaceURI: string | null): boolean; isEqualNode(arg: Node): boolean; isSameNode(other: Node): boolean; lookupNamespaceURI(prefix: string | null): string | null; lookupPrefix(namespaceURI: string | null): string | null; normalize(): void; - removeChild(oldChild: Node): Node; - replaceChild(newChild: Node, oldChild: Node): Node; + removeChild(oldChild: T): T; + replaceChild(newChild: Node, oldChild: T): T; readonly ATTRIBUTE_NODE: number; readonly CDATA_SECTION_NODE: number; readonly COMMENT_NODE: number; @@ -8363,14 +8369,14 @@ interface NotificationEventMap { interface Notification extends EventTarget { readonly body: string; - readonly dir: string; + readonly dir: NotificationDirection; readonly icon: string; readonly lang: string; onclick: (this: Notification, ev: Event) => any; onclose: (this: Notification, ev: Event) => any; onerror: (this: Notification, ev: Event) => any; onshow: (this: Notification, ev: Event) => any; - readonly permission: string; + readonly permission: NotificationPermission; readonly tag: string; readonly title: string; close(): void; @@ -8381,7 +8387,7 @@ interface Notification extends EventTarget { declare var Notification: { prototype: Notification; new(title: string, options?: NotificationOptions): Notification; - requestPermission(callback?: NotificationPermissionCallback): Promise; + requestPermission(callback?: NotificationPermissionCallback): Promise; } interface OES_element_index_uint { @@ -8471,7 +8477,7 @@ interface OscillatorNode extends AudioNode { readonly detune: AudioParam; readonly frequency: AudioParam; onended: (this: OscillatorNode, ev: MediaStreamErrorEvent) => any; - type: string; + type: OscillatorType; setPeriodicWave(periodicWave: PeriodicWave): void; start(when?: number): void; stop(when?: number): void; @@ -8514,9 +8520,9 @@ interface PannerNode extends AudioNode { coneInnerAngle: number; coneOuterAngle: number; coneOuterGain: number; - distanceModel: string; + distanceModel: DistanceModelType; maxDistance: number; - panningModel: string; + panningModel: PanningModelType; refDistance: number; rolloffFactor: number; setOrientation(x: number, y: number, z: number): void; @@ -8567,7 +8573,7 @@ interface PaymentRequest extends EventTarget { onshippingoptionchange: (this: PaymentRequest, ev: Event) => any; readonly shippingAddress: PaymentAddress | null; readonly shippingOption: string | null; - readonly shippingType: string | null; + readonly shippingType: PaymentShippingType | null; abort(): Promise; show(): Promise; addEventListener(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, useCapture?: boolean): void; @@ -8596,7 +8602,7 @@ interface PaymentResponse { readonly payerPhone: string | null; readonly shippingAddress: PaymentAddress | null; readonly shippingOption: string | null; - complete(result?: string): Promise; + complete(result?: PaymentComplete): Promise; toJSON(): any; } @@ -8724,7 +8730,7 @@ interface PerformanceNavigationTiming extends PerformanceEntry { readonly requestStart: number; readonly responseEnd: number; readonly responseStart: number; - readonly type: string; + readonly type: NavigationType; readonly unloadEventEnd: number; readonly unloadEventStart: number; } @@ -8793,7 +8799,7 @@ declare var PeriodicWave: { } interface PermissionRequest extends DeferredPermissionRequest { - readonly state: string; + readonly state: MSWebViewPermissionState; defer(): void; } @@ -8923,7 +8929,7 @@ declare var ProgressEvent: { interface PushManager { getSubscription(): Promise; - permissionState(options?: PushSubscriptionOptionsInit): Promise; + permissionState(options?: PushSubscriptionOptionsInit): Promise; subscribe(options?: PushSubscriptionOptionsInit): Promise; } @@ -8935,7 +8941,7 @@ declare var PushManager: { interface PushSubscription { readonly endpoint: USVString; readonly options: PushSubscriptionOptions; - getKey(name: string): ArrayBuffer | null; + getKey(name: PushEncryptionKeyName): ArrayBuffer | null; toJSON(): any; unsubscribe(): Promise; } @@ -8972,7 +8978,7 @@ interface RTCDtlsTransportEventMap { interface RTCDtlsTransport extends RTCStatsProvider { ondtlsstatechange: ((this: RTCDtlsTransport, ev: RTCDtlsTransportStateChangedEvent) => any) | null; onerror: ((this: RTCDtlsTransport, ev: Event) => any) | null; - readonly state: string; + readonly state: RTCDtlsTransportState; readonly transport: RTCIceTransport; getLocalParameters(): RTCDtlsParameters; getRemoteCertificates(): ArrayBuffer[]; @@ -8989,7 +8995,7 @@ declare var RTCDtlsTransport: { } interface RTCDtlsTransportStateChangedEvent extends Event { - readonly state: string; + readonly state: RTCDtlsTransportState; } declare var RTCDtlsTransportStateChangedEvent: { @@ -9045,7 +9051,7 @@ interface RTCIceGathererEventMap { } interface RTCIceGatherer extends RTCStatsProvider { - readonly component: string; + readonly component: RTCIceComponent; onerror: ((this: RTCIceGatherer, ev: Event) => any) | null; onlocalcandidate: ((this: RTCIceGatherer, ev: RTCIceGathererEvent) => any) | null; createAssociatedGatherer(): RTCIceGatherer; @@ -9075,19 +9081,19 @@ interface RTCIceTransportEventMap { } interface RTCIceTransport extends RTCStatsProvider { - readonly component: string; + readonly component: RTCIceComponent; readonly iceGatherer: RTCIceGatherer | null; oncandidatepairchange: ((this: RTCIceTransport, ev: RTCIceCandidatePairChangedEvent) => any) | null; onicestatechange: ((this: RTCIceTransport, ev: RTCIceTransportStateChangedEvent) => any) | null; - readonly role: string; - readonly state: string; + readonly role: RTCIceRole; + readonly state: RTCIceTransportState; addRemoteCandidate(remoteCandidate: RTCIceCandidateDictionary | RTCIceCandidateComplete): void; createAssociatedTransport(): RTCIceTransport; getNominatedCandidatePair(): RTCIceCandidatePair | null; getRemoteCandidates(): RTCIceCandidateDictionary[]; getRemoteParameters(): RTCIceParameters | null; setRemoteCandidates(remoteCandidates: RTCIceCandidateDictionary[]): void; - start(gatherer: RTCIceGatherer, remoteParameters: RTCIceParameters, role?: string): void; + start(gatherer: RTCIceGatherer, remoteParameters: RTCIceParameters, role?: RTCIceRole): void; stop(): void; addEventListener(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; @@ -9099,7 +9105,7 @@ declare var RTCIceTransport: { } interface RTCIceTransportStateChangedEvent extends Event { - readonly state: string; + readonly state: RTCIceTransportState; } declare var RTCIceTransportStateChangedEvent: { @@ -9119,8 +9125,8 @@ interface RTCPeerConnectionEventMap { interface RTCPeerConnection extends EventTarget { readonly canTrickleIceCandidates: boolean | null; - readonly iceConnectionState: string; - readonly iceGatheringState: string; + readonly iceConnectionState: RTCIceConnectionState; + readonly iceGatheringState: RTCIceGatheringState; readonly localDescription: RTCSessionDescription | null; onaddstream: (this: RTCPeerConnection, ev: MediaStreamEvent) => any; onicecandidate: (this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent) => any; @@ -9130,7 +9136,7 @@ interface RTCPeerConnection extends EventTarget { onremovestream: (this: RTCPeerConnection, ev: MediaStreamEvent) => any; onsignalingstatechange: (this: RTCPeerConnection, ev: Event) => any; readonly remoteDescription: RTCSessionDescription | null; - readonly signalingState: string; + readonly signalingState: RTCSignalingState; addIceCandidate(candidate: RTCIceCandidate, successCallback?: VoidFunction, failureCallback?: RTCPeerConnectionErrorCallback): Promise; addStream(stream: MediaStream): void; close(): void; @@ -9213,7 +9219,7 @@ declare var RTCRtpSender: { interface RTCSessionDescription { sdp: string | null; - type: string | null; + type: RTCSdpType | null; toJSON(): any; } @@ -9272,7 +9278,7 @@ interface Range { createContextualFragment(fragment: string): DocumentFragment; deleteContents(): void; detach(): void; - expand(Unit: string): boolean; + expand(Unit: ExpandGranularity): boolean; extractContents(): DocumentFragment; getBoundingClientRect(): ClientRect; getClientRects(): ClientRectList; @@ -9325,18 +9331,18 @@ declare var ReadableStreamReader: { } interface Request extends Object, Body { - readonly cache: string; - readonly credentials: string; - readonly destination: string; + readonly cache: RequestCache; + readonly credentials: RequestCredentials; + readonly destination: RequestDestination; readonly headers: Headers; readonly integrity: string; readonly keepalive: boolean; readonly method: string; - readonly mode: string; - readonly redirect: string; + readonly mode: RequestMode; + readonly redirect: RequestRedirect; readonly referrer: string; - readonly referrerPolicy: string; - readonly type: string; + readonly referrerPolicy: ReferrerPolicy; + readonly type: RequestType; readonly url: string; clone(): Request; } @@ -9352,7 +9358,7 @@ interface Response extends Object, Body { readonly ok: boolean; readonly status: number; readonly statusText: string; - readonly type: string; + readonly type: ResponseType; readonly url: string; clone(): Response; } @@ -11152,7 +11158,7 @@ declare var SVGZoomEvent: { interface ScopedCredential { readonly id: ArrayBuffer; - readonly type: string; + readonly type: ScopedCredentialType; } declare var ScopedCredential: { @@ -11269,7 +11275,7 @@ interface ServiceWorkerEventMap extends AbstractWorkerEventMap { interface ServiceWorker extends EventTarget, AbstractWorker { onstatechange: (this: ServiceWorker, ev: Event) => any; readonly scriptURL: USVString; - readonly state: string; + readonly state: ServiceWorkerState; postMessage(message: any, transfer?: any[]): void; addEventListener(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; @@ -11345,7 +11351,7 @@ interface SourceBuffer extends EventTarget { appendWindowStart: number; readonly audioTracks: AudioTrackList; readonly buffered: TimeRanges; - mode: string; + mode: AppendMode; timestampOffset: number; readonly updating: boolean; readonly videoTracks: VideoTrackList; @@ -11581,7 +11587,7 @@ interface Text extends CharacterData { declare var Text: { prototype: Text; - new(): Text; + new(data?: string): Text; } interface TextEvent extends UIEvent { @@ -11764,7 +11770,7 @@ interface TouchEvent extends UIEvent { declare var TouchEvent: { prototype: TouchEvent; - new(): TouchEvent; + new(type: string, touchEventInit?: TouchEventInit): TouchEvent; } interface TouchList { @@ -11970,7 +11976,7 @@ declare var WEBGL_depth_texture: { interface WaveShaperNode extends AudioNode { curve: Float32Array | null; - oversample: string; + oversample: OverSampleType; } declare var WaveShaperNode: { @@ -13231,6 +13237,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window readonly top: Window; readonly window: Window; URL: typeof URL; + URLSearchParams: typeof URLSearchParams; Blob: typeof Blob; customElements: CustomElementRegistry; alert(message?: any): void; @@ -13239,7 +13246,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window captureEvents(): void; close(): void; confirm(message?: string): boolean; - departFocus(navigationReason: string, origin: FocusNavigationOrigin): void; + departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void; focus(): void; getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration; getMatchedCSSRules(elt: Element, pseudoElt?: string): CSSRuleList; @@ -13314,7 +13321,7 @@ interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget { readonly readyState: number; readonly response: any; readonly responseText: string; - responseType: string; + responseType: XMLHttpRequestResponseType; readonly responseURL: string; readonly responseXML: Document | null; readonly status: number; @@ -14171,6 +14178,21 @@ interface PromiseRejectionEventInit extends EventInit { reason?: any; } +interface EventListenerOptions { + capture?: boolean; +} + +interface AddEventListenerOptions extends EventListenerOptions { + passive?: boolean; + once?: boolean; +} + +interface TouchEventInit extends EventModifierInit { + touches?: Touch[]; + targetTouches?: Touch[]; + changedTouches?: Touch[]; +} + declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject; interface ErrorEventHandler { @@ -14228,10 +14250,10 @@ interface NavigatorUserMediaErrorCallback { (error: MediaStreamError): void; } interface ForEachCallback { - (keyId: any, status: string): void; + (keyId: any, status: MediaKeyStatus): void; } interface NotificationPermissionCallback { - (permission: string): void; + (permission: NotificationPermission): void; } interface IntersectionObserverCallback { (entries: IntersectionObserverEntry[], observer: IntersectionObserver): void; @@ -14838,7 +14860,7 @@ declare function cancelAnimationFrame(handle: number): void; declare function captureEvents(): void; declare function close(): void; declare function confirm(message?: string): boolean; -declare function departFocus(navigationReason: string, origin: FocusNavigationOrigin): void; +declare function departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void; declare function focus(): void; declare function getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration; declare function getMatchedCSSRules(elt: Element, pseudoElt?: string): CSSRuleList; @@ -14870,7 +14892,7 @@ declare function scrollTo(options?: ScrollToOptions): void; declare function scrollBy(options?: ScrollToOptions): void; declare function toString(): string; declare function dispatchEvent(evt: Event): boolean; -declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void; +declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; declare function clearInterval(handle: number): void; declare function clearTimeout(handle: number): void; declare function setInterval(handler: (...args: any[]) => void, timeout: number): number; @@ -14939,4 +14961,76 @@ type ScrollLogicalPosition = "start" | "center" | "end" | "nearest"; type IDBValidKey = number | string | Date | IDBArrayKey; type BufferSource = ArrayBuffer | ArrayBufferView; type MouseWheelEvent = WheelEvent; -type ScrollRestoration = "auto" | "manual"; \ No newline at end of file +type ScrollRestoration = "auto" | "manual"; +type FormDataEntryValue = string | File; +type AppendMode = "segments" | "sequence"; +type AudioContextState = "suspended" | "running" | "closed"; +type BiquadFilterType = "lowpass" | "highpass" | "bandpass" | "lowshelf" | "highshelf" | "peaking" | "notch" | "allpass"; +type CanvasFillRule = "nonzero" | "evenodd"; +type ChannelCountMode = "max" | "clamped-max" | "explicit"; +type ChannelInterpretation = "speakers" | "discrete"; +type DistanceModelType = "linear" | "inverse" | "exponential"; +type ExpandGranularity = "character" | "word" | "sentence" | "textedit"; +type GamepadInputEmulationType = "mouse" | "keyboard" | "gamepad"; +type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique"; +type IDBRequestReadyState = "pending" | "done"; +type IDBTransactionMode = "readonly" | "readwrite" | "versionchange"; +type ListeningState = "inactive" | "active" | "disambiguation"; +type MSCredentialType = "FIDO_2_0"; +type MSIceAddrType = "os" | "stun" | "turn" | "peer-derived"; +type MSIceType = "failed" | "direct" | "relay"; +type MSStatsType = "description" | "localclientevent" | "inbound-network" | "outbound-network" | "inbound-payload" | "outbound-payload" | "transportdiagnostics"; +type MSTransportType = "Embedded" | "USB" | "NFC" | "BT"; +type MSWebViewPermissionState = "unknown" | "defer" | "allow" | "deny"; +type MSWebViewPermissionType = "geolocation" | "unlimitedIndexedDBQuota" | "media" | "pointerlock" | "webnotifications"; +type MediaDeviceKind = "audioinput" | "audiooutput" | "videoinput"; +type MediaKeyMessageType = "license-request" | "license-renewal" | "license-release" | "individualization-request"; +type MediaKeySessionType = "temporary" | "persistent-license" | "persistent-release-message"; +type MediaKeyStatus = "usable" | "expired" | "output-downscaled" | "output-not-allowed" | "status-pending" | "internal-error"; +type MediaKeysRequirement = "required" | "optional" | "not-allowed"; +type MediaStreamTrackState = "live" | "ended"; +type NavigationReason = "up" | "down" | "left" | "right"; +type NavigationType = "navigate" | "reload" | "back_forward" | "prerender"; +type NotificationDirection = "auto" | "ltr" | "rtl"; +type NotificationPermission = "default" | "denied" | "granted"; +type OscillatorType = "sine" | "square" | "sawtooth" | "triangle" | "custom"; +type OverSampleType = "none" | "2x" | "4x"; +type PanningModelType = "equalpower"; +type PaymentComplete = "success" | "fail" | ""; +type PaymentShippingType = "shipping" | "delivery" | "pickup"; +type PushEncryptionKeyName = "p256dh" | "auth"; +type PushPermissionState = "granted" | "denied" | "prompt"; +type RTCBundlePolicy = "balanced" | "max-compat" | "max-bundle"; +type RTCDegradationPreference = "maintain-framerate" | "maintain-resolution" | "balanced"; +type RTCDtlsRole = "auto" | "client" | "server"; +type RTCDtlsTransportState = "new" | "connecting" | "connected" | "closed"; +type RTCIceCandidateType = "host" | "srflx" | "prflx" | "relay"; +type RTCIceComponent = "RTP" | "RTCP"; +type RTCIceConnectionState = "new" | "checking" | "connected" | "completed" | "failed" | "disconnected" | "closed"; +type RTCIceGatherPolicy = "all" | "nohost" | "relay"; +type RTCIceGathererState = "new" | "gathering" | "complete"; +type RTCIceGatheringState = "new" | "gathering" | "complete"; +type RTCIceProtocol = "udp" | "tcp"; +type RTCIceRole = "controlling" | "controlled"; +type RTCIceTcpCandidateType = "active" | "passive" | "so"; +type RTCIceTransportPolicy = "none" | "relay" | "all"; +type RTCIceTransportState = "new" | "checking" | "connected" | "completed" | "disconnected" | "closed"; +type RTCSdpType = "offer" | "pranswer" | "answer"; +type RTCSignalingState = "stable" | "have-local-offer" | "have-remote-offer" | "have-local-pranswer" | "have-remote-pranswer" | "closed"; +type RTCStatsIceCandidatePairState = "frozen" | "waiting" | "inprogress" | "failed" | "succeeded" | "cancelled"; +type RTCStatsIceCandidateType = "host" | "serverreflexive" | "peerreflexive" | "relayed"; +type RTCStatsType = "inboundrtp" | "outboundrtp" | "session" | "datachannel" | "track" | "transport" | "candidatepair" | "localcandidate" | "remotecandidate"; +type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin-only" | "origin-when-cross-origin" | "unsafe-url"; +type RequestCache = "default" | "no-store" | "reload" | "no-cache" | "force-cache"; +type RequestCredentials = "omit" | "same-origin" | "include"; +type RequestDestination = "" | "document" | "sharedworker" | "subresource" | "unknown" | "worker"; +type RequestMode = "navigate" | "same-origin" | "no-cors" | "cors"; +type RequestRedirect = "follow" | "error" | "manual"; +type RequestType = "" | "audio" | "font" | "image" | "script" | "style" | "track" | "video"; +type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect"; +type ScopedCredentialType = "ScopedCred"; +type ServiceWorkerState = "installing" | "installed" | "activating" | "activated" | "redundant"; +type Transport = "usb" | "nfc" | "ble"; +type VideoFacingModeEnum = "user" | "environment" | "left" | "right"; +type VisibilityState = "hidden" | "visible" | "prerender" | "unloaded"; +type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text"; \ No newline at end of file diff --git a/src/lib/webworker.generated.d.ts b/src/lib/webworker.generated.d.ts index 326a3a9546e..62d6d2d67a7 100644 --- a/src/lib/webworker.generated.d.ts +++ b/src/lib/webworker.generated.d.ts @@ -54,13 +54,17 @@ interface MessageEventInit extends EventInit { } interface NotificationOptions { - dir?: string; + dir?: NotificationDirection; lang?: string; body?: string; tag?: string; icon?: string; } +interface ObjectURLOptions { + oneTimeOnly?: boolean; +} + interface PushSubscriptionOptionsInit { userVisibleOnly?: boolean; applicationServerKey?: any; @@ -71,11 +75,11 @@ interface RequestInit { headers?: any; body?: any; referrer?: string; - referrerPolicy?: string; - mode?: string; - credentials?: string; - cache?: string; - redirect?: string; + referrerPolicy?: ReferrerPolicy; + mode?: RequestMode; + credentials?: RequestCredentials; + cache?: RequestCache; + redirect?: RequestRedirect; integrity?: string; keepalive?: boolean; window?: any; @@ -89,7 +93,7 @@ interface ResponseInit { interface ClientQueryOptions { includeUncontrolled?: boolean; - type?: string; + type?: ClientType; } interface ExtendableEventInit extends EventInit { @@ -399,9 +403,9 @@ declare var Event: { } interface EventTarget { - addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void; + addEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; dispatchEvent(evt: Event): boolean; - removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void; + removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } declare var EventTarget: { @@ -461,7 +465,7 @@ declare var Headers: { } interface IDBCursor { - readonly direction: string; + readonly direction: IDBCursorDirection; key: IDBKeyRange | IDBValidKey; readonly primaryKey: any; source: IDBObjectStore | IDBIndex; @@ -613,7 +617,7 @@ interface IDBRequest extends EventTarget { readonly error: DOMError; onerror: (this: IDBRequest, ev: Event) => any; onsuccess: (this: IDBRequest, ev: Event) => any; - readonly readyState: string; + readonly readyState: IDBRequestReadyState; readonly result: any; source: IDBObjectStore | IDBIndex | IDBCursor; readonly transaction: IDBTransaction; @@ -635,7 +639,7 @@ interface IDBTransactionEventMap { interface IDBTransaction extends EventTarget { readonly db: IDBDatabase; readonly error: DOMError; - readonly mode: string; + readonly mode: IDBTransactionMode; onabort: (this: IDBTransaction, ev: Event) => any; oncomplete: (this: IDBTransaction, ev: Event) => any; onerror: (this: IDBTransaction, ev: Event) => any; @@ -728,14 +732,14 @@ interface NotificationEventMap { interface Notification extends EventTarget { readonly body: string; - readonly dir: string; + readonly dir: NotificationDirection; readonly icon: string; readonly lang: string; onclick: (this: Notification, ev: Event) => any; onclose: (this: Notification, ev: Event) => any; onerror: (this: Notification, ev: Event) => any; onshow: (this: Notification, ev: Event) => any; - readonly permission: string; + readonly permission: NotificationPermission; readonly tag: string; readonly title: string; close(): void; @@ -746,7 +750,7 @@ interface Notification extends EventTarget { declare var Notification: { prototype: Notification; new(title: string, options?: NotificationOptions): Notification; - requestPermission(callback?: NotificationPermissionCallback): Promise; + requestPermission(callback?: NotificationPermissionCallback): Promise; } interface Performance { @@ -863,7 +867,7 @@ declare var ProgressEvent: { interface PushManager { getSubscription(): Promise; - permissionState(options?: PushSubscriptionOptionsInit): Promise; + permissionState(options?: PushSubscriptionOptionsInit): Promise; subscribe(options?: PushSubscriptionOptionsInit): Promise; } @@ -875,7 +879,7 @@ declare var PushManager: { interface PushSubscription { readonly endpoint: USVString; readonly options: PushSubscriptionOptions; - getKey(name: string): ArrayBuffer | null; + getKey(name: PushEncryptionKeyName): ArrayBuffer | null; toJSON(): any; unsubscribe(): Promise; } @@ -918,18 +922,18 @@ declare var ReadableStreamReader: { } interface Request extends Object, Body { - readonly cache: string; - readonly credentials: string; - readonly destination: string; + readonly cache: RequestCache; + readonly credentials: RequestCredentials; + readonly destination: RequestDestination; readonly headers: Headers; readonly integrity: string; readonly keepalive: boolean; readonly method: string; - readonly mode: string; - readonly redirect: string; + readonly mode: RequestMode; + readonly redirect: RequestRedirect; readonly referrer: string; - readonly referrerPolicy: string; - readonly type: string; + readonly referrerPolicy: ReferrerPolicy; + readonly type: RequestType; readonly url: string; clone(): Request; } @@ -945,7 +949,7 @@ interface Response extends Object, Body { readonly ok: boolean; readonly status: number; readonly statusText: string; - readonly type: string; + readonly type: ResponseType; readonly url: string; clone(): Response; } @@ -962,7 +966,7 @@ interface ServiceWorkerEventMap extends AbstractWorkerEventMap { interface ServiceWorker extends EventTarget, AbstractWorker { onstatechange: (this: ServiceWorker, ev: Event) => any; readonly scriptURL: USVString; - readonly state: string; + readonly state: ServiceWorkerState; postMessage(message: any, transfer?: any[]): void; addEventListener(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; @@ -1008,6 +1012,29 @@ declare var SyncManager: { new(): SyncManager; } +interface URL { + hash: string; + host: string; + hostname: string; + href: string; + readonly origin: string; + password: string; + pathname: string; + port: string; + protocol: string; + search: string; + username: string; + readonly searchParams: URLSearchParams; + toString(): string; +} + +declare var URL: { + prototype: URL; + new(url: string, base?: string): URL; + createObjectURL(object: any, options?: ObjectURLOptions): string; + revokeObjectURL(url: string): void; +} + interface WebSocketEventMap { "close": CloseEvent; "error": Event; @@ -1071,7 +1098,7 @@ interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget { readonly readyState: number; readonly response: any; readonly responseText: string; - responseType: string; + responseType: XMLHttpRequestResponseType; readonly responseURL: string; readonly responseXML: any; readonly status: number; @@ -1222,7 +1249,7 @@ interface XMLHttpRequestEventTarget { } interface Client { - readonly frameType: string; + readonly frameType: FrameType; readonly id: string; readonly url: USVString; postMessage(message: any, transfer?: any[]): void; @@ -1385,7 +1412,7 @@ declare var SyncEvent: { interface WindowClient extends Client { readonly focused: boolean; - readonly visibilityState: string; + readonly visibilityState: VisibilityState; focus(): Promise; navigate(url: USVString): Promise; } @@ -1484,6 +1511,41 @@ interface ImageBitmap { close(): void; } +interface URLSearchParams { + /** + * Appends a specified key/value pair as a new search parameter. + */ + append(name: string, value: string): void; + /** + * Deletes the given search parameter, and its associated value, from the list of all search parameters. + */ + delete(name: string): void; + /** + * Returns the first value associated to the given search parameter. + */ + get(name: string): string | null; + /** + * Returns all the values association with a given search parameter. + */ + getAll(name: string): string[]; + /** + * Returns a Boolean indicating if such a search parameter exists. + */ + has(name: string): boolean; + /** + * Sets the value associated to a given search parameter to the given value. If there were several values, delete the others. + */ + set(name: string, value: string): void; +} + +declare var URLSearchParams: { + prototype: URLSearchParams; + /** + * Constructor returning a URLSearchParams object. + */ + new (init?: string | URLSearchParams): URLSearchParams; +} + interface BlobPropertyBag { type?: string; endings?: string; @@ -1678,6 +1740,15 @@ interface JsonWebKey { k?: string; } +interface EventListenerOptions { + capture?: boolean; +} + +interface AddEventListenerOptions extends EventListenerOptions { + passive?: boolean; + once?: boolean; +} + declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject; interface ErrorEventHandler { @@ -1699,10 +1770,10 @@ interface FunctionStringCallback { (data: string): void; } interface ForEachCallback { - (keyId: any, status: string): void; + (keyId: any, status: MediaKeyStatus): void; } interface NotificationPermissionCallback { - (permission: string): void; + (permission: NotificationPermission): void; } declare var onmessage: (this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any; declare function close(): void; @@ -1717,7 +1788,7 @@ declare function msWriteProfilerMark(profilerMarkName: string): void; declare function createImageBitmap(image: ImageBitmap | ImageData | Blob, options?: ImageBitmapOptions): Promise; declare function createImageBitmap(image: ImageBitmap | ImageData | Blob, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise; declare function dispatchEvent(evt: Event): boolean; -declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void; +declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; declare var indexedDB: IDBFactory; declare var msIndexedDB: IDBFactory; declare var navigator: WorkerNavigator; @@ -1736,7 +1807,7 @@ declare function btoa(rawString: string): string; declare var console: Console; declare function fetch(input: RequestInfo, init?: RequestInit): Promise; declare function dispatchEvent(evt: Event): boolean; -declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void; +declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; declare function addEventListener(type: K, listener: (this: DedicatedWorkerGlobalScope, ev: DedicatedWorkerGlobalScopeEventMap[K]) => any, useCapture?: boolean): void; declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; type AlgorithmIdentifier = string | Algorithm; @@ -1745,4 +1816,26 @@ type IDBKeyPath = string; type RequestInfo = Request | string; type USVString = string; type IDBValidKey = number | string | Date | IDBArrayKey; -type BufferSource = ArrayBuffer | ArrayBufferView; \ No newline at end of file +type BufferSource = ArrayBuffer | ArrayBufferView; +type FormDataEntryValue = string | File; +type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique"; +type IDBRequestReadyState = "pending" | "done"; +type IDBTransactionMode = "readonly" | "readwrite" | "versionchange"; +type MediaKeyStatus = "usable" | "expired" | "output-downscaled" | "output-not-allowed" | "status-pending" | "internal-error"; +type NotificationDirection = "auto" | "ltr" | "rtl"; +type NotificationPermission = "default" | "denied" | "granted"; +type PushEncryptionKeyName = "p256dh" | "auth"; +type PushPermissionState = "granted" | "denied" | "prompt"; +type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin-only" | "origin-when-cross-origin" | "unsafe-url"; +type RequestCache = "default" | "no-store" | "reload" | "no-cache" | "force-cache"; +type RequestCredentials = "omit" | "same-origin" | "include"; +type RequestDestination = "" | "document" | "sharedworker" | "subresource" | "unknown" | "worker"; +type RequestMode = "navigate" | "same-origin" | "no-cors" | "cors"; +type RequestRedirect = "follow" | "error" | "manual"; +type RequestType = "" | "audio" | "font" | "image" | "script" | "style" | "track" | "video"; +type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect"; +type ServiceWorkerState = "installing" | "installed" | "activating" | "activated" | "redundant"; +type VisibilityState = "hidden" | "visible" | "prerender" | "unloaded"; +type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text"; +type ClientType = "window" | "worker" | "sharedworker" | "all"; +type FrameType = "auxiliary" | "top-level" | "nested" | "none"; \ No newline at end of file From 3cc379c3c0c8f3e5ee8b1be5bad8bbc31cfcb610 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 13 Apr 2017 16:16:57 -0700 Subject: [PATCH 27/35] Fix merge --- src/harness/harnessLanguageService.ts | 18 +++-- .../unittests/cachingInServerLSHost.ts | 12 ++- src/harness/unittests/compileOnSave.ts | 40 ++++++---- src/harness/unittests/session.ts | 38 ++++++++- .../unittests/tsserverProjectSystem.ts | 18 ++++- src/server/editorServices.ts | 48 +++++++++--- src/server/project.ts | 30 ++++++-- src/server/server.ts | 77 +++++++++++-------- src/server/session.ts | 72 ++++++++++++----- 9 files changed, 258 insertions(+), 95 deletions(-) diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts index c6477240161..3bf6f1cde9a 100644 --- a/src/harness/harnessLanguageService.ts +++ b/src/harness/harnessLanguageService.ts @@ -818,13 +818,17 @@ namespace Harness.LanguageService { // This host is just a proxy for the clientHost, it uses the client // host to answer server queries about files on disk const serverHost = new SessionServerHost(clientHost); - const server = new ts.server.Session(serverHost, - ts.server.nullCancellationToken, - /*useOneInferredProject*/ false, - /*typingsInstaller*/ undefined, - Utils.byteLength, - process.hrtime, serverHost, - /*canUseEvents*/ true); + const opts: ts.server.SessionOptions = { + host: serverHost, + cancellationToken: ts.server.nullCancellationToken, + useSingleInferredProject: false, + typingsInstaller: undefined, + byteLength: Utils.byteLength, + hrtime: process.hrtime, + logger: serverHost, + canUseEvents: true + }; + const server = new ts.server.Session(opts); // Fake the connection between the client and the server serverHost.writeMessage = client.onMessage.bind(client); diff --git a/src/harness/unittests/cachingInServerLSHost.ts b/src/harness/unittests/cachingInServerLSHost.ts index 5389c8f37f8..5ce93fa8231 100644 --- a/src/harness/unittests/cachingInServerLSHost.ts +++ b/src/harness/unittests/cachingInServerLSHost.ts @@ -64,8 +64,16 @@ namespace ts { getLogFileName: (): string => undefined }; - const projectService = new server.ProjectService(serverHost, logger, { isCancellationRequested: () => false }, /*useOneInferredProject*/ false, /*typingsInstaller*/ undefined); - const rootScriptInfo = projectService.getOrCreateScriptInfo(rootFile, /*openedByClient*/ true, /*containingProject*/ undefined); + const svcOpts: server.ProjectServiceOptions = { + host: serverHost, + logger, + cancellationToken: { isCancellationRequested: () => false }, + useSingleInferredProject: false, + typingsInstaller: undefined + }; + const projectService = new server.ProjectService(svcOpts); + const rootScriptInfo = projectService.getOrCreateScriptInfo(rootFile, /* openedByClient */true, /*containingProject*/ undefined); + const project = projectService.createInferredProjectWithRootFileIfNecessary(rootScriptInfo); project.setCompilerOptions({ module: ts.ModuleKind.AMD } ); return { diff --git a/src/harness/unittests/compileOnSave.ts b/src/harness/unittests/compileOnSave.ts index 114ee77fef1..506559bd3d9 100644 --- a/src/harness/unittests/compileOnSave.ts +++ b/src/harness/unittests/compileOnSave.ts @@ -31,6 +31,20 @@ namespace ts.projectSystem { } } + function createSession(host: server.ServerHost, typingsInstaller?: server.ITypingsInstaller): server.Session { + const opts: server.SessionOptions = { + host, + cancellationToken: nullCancellationToken, + useSingleInferredProject: false, + typingsInstaller: typingsInstaller || server.nullTypingsInstaller, + byteLength: Utils.byteLength, + hrtime: process.hrtime, + logger: nullLogger, + canUseEvents: false + }; + return new server.Session(opts); + } + describe("for configured projects", () => { let moduleFile1: FileOrFolder; let file1Consumer1: FileOrFolder; @@ -113,7 +127,7 @@ namespace ts.projectSystem { it("should contains only itself if a module file's shape didn't change, and all files referencing it if its shape changed", () => { const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([moduleFile1, file1Consumer1], session); @@ -138,7 +152,7 @@ namespace ts.projectSystem { it("should be up-to-date with the reference map changes", () => { const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([moduleFile1, file1Consumer1], session); @@ -185,7 +199,7 @@ namespace ts.projectSystem { it("should be up-to-date with changes made in non-open files", () => { const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([moduleFile1], session); @@ -203,7 +217,7 @@ namespace ts.projectSystem { it("should be up-to-date with deleted files", () => { const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([moduleFile1], session); sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]); @@ -218,7 +232,7 @@ namespace ts.projectSystem { it("should be up-to-date with newly created files", () => { const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([moduleFile1], session); sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]); @@ -255,7 +269,7 @@ namespace ts.projectSystem { const host = createServerHost([moduleFile1, file1Consumer1, configFile, libFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([moduleFile1, file1Consumer1], session); sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1] }]); @@ -272,7 +286,7 @@ namespace ts.projectSystem { it("should return all files if a global file changed shape", () => { const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([globalFile3], session); const changeGlobalFile3ShapeRequest = makeSessionRequest(CommandNames.Change, { @@ -298,7 +312,7 @@ namespace ts.projectSystem { const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, configFile, libFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([moduleFile1], session); sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, []); }); @@ -316,7 +330,7 @@ namespace ts.projectSystem { const host = createServerHost([moduleFile1, file1Consumer1, configFile, libFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([moduleFile1], session); const file1ChangeShapeRequest = makeSessionRequest(CommandNames.Change, { @@ -345,7 +359,7 @@ namespace ts.projectSystem { const host = createServerHost([moduleFile1, file1Consumer1, configFile, libFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([moduleFile1], session); const file1ChangeShapeRequest = makeSessionRequest(CommandNames.Change, { @@ -367,7 +381,7 @@ namespace ts.projectSystem { }; const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer1Consumer1, globalFile3, configFile, libFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([moduleFile1, file1Consumer1], session); sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer1Consumer1] }]); @@ -400,7 +414,7 @@ namespace ts.projectSystem { }; const host = createServerHost([file1, file2, configFile]); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([file1, file2], session); const file1AffectedListRequest = makeSessionRequest(CommandNames.CompileOnSaveAffectedFileList, { file: file1.path }); @@ -513,7 +527,7 @@ namespace ts.projectSystem { }; const host = createServerHost([file1, file2, configFile, libFile], { newLine: "\r\n" }); const typingsInstaller = createTestTypingsInstaller(host); - const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false); + const session = createSession(host, typingsInstaller); openFilesForSession([file1, file2], session); const compileFileRequest = makeSessionRequest(CommandNames.CompileOnSaveEmitFile, { file: file1.path, projectFileName: configFile.path }); diff --git a/src/harness/unittests/session.ts b/src/harness/unittests/session.ts index 9a38de7da10..a505c3ee7be 100644 --- a/src/harness/unittests/session.ts +++ b/src/harness/unittests/session.ts @@ -50,8 +50,22 @@ namespace ts.server { let session: TestSession; let lastSent: protocol.Message; + function createSession(): TestSession { + const opts: server.SessionOptions = { + host: mockHost, + cancellationToken: nullCancellationToken, + useSingleInferredProject: false, + typingsInstaller: undefined, + byteLength: Utils.byteLength, + hrtime: process.hrtime, + logger: mockLogger, + canUseEvents: true + }; + return new TestSession(opts); + } + beforeEach(() => { - session = new TestSession(mockHost, nullCancellationToken, /*useOneInferredProject*/ false, /*typingsInstaller*/ undefined, Utils.byteLength, process.hrtime, mockLogger, /*canUseEvents*/ true); + session = createSession(); session.send = (msg: protocol.Message) => { lastSent = msg; }; @@ -318,7 +332,16 @@ namespace ts.server { lastSent: protocol.Message; customHandler = "testhandler"; constructor() { - super(mockHost, nullCancellationToken, /*useOneInferredProject*/ false, /*typingsInstaller*/ undefined, Utils.byteLength, process.hrtime, mockLogger, /*canUseEvents*/ true); + super({ + host: mockHost, + cancellationToken: nullCancellationToken, + useSingleInferredProject: false, + typingsInstaller: undefined, + byteLength: Utils.byteLength, + hrtime: process.hrtime, + logger: mockLogger, + canUseEvents: true + }); this.addProtocolHandler(this.customHandler, () => { return { response: undefined, responseRequired: true }; }); @@ -376,7 +399,16 @@ namespace ts.server { class InProcSession extends Session { private queue: protocol.Request[] = []; constructor(private client: InProcClient) { - super(mockHost, nullCancellationToken, /*useOneInferredProject*/ false, /*typingsInstaller*/ undefined, Utils.byteLength, process.hrtime, mockLogger, /*canUseEvents*/ true); + super({ + host: mockHost, + cancellationToken: nullCancellationToken, + useSingleInferredProject: false, + typingsInstaller: undefined, + byteLength: Utils.byteLength, + hrtime: process.hrtime, + logger: mockLogger, + canUseEvents: true + }); this.addProtocolHandler("echo", (req: protocol.Request) => ({ response: req.arguments, responseRequired: true diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts index 8364420709c..81931a2de41 100644 --- a/src/harness/unittests/tsserverProjectSystem.ts +++ b/src/harness/unittests/tsserverProjectSystem.ts @@ -190,7 +190,19 @@ namespace ts.projectSystem { if (typingsInstaller === undefined) { typingsInstaller = new TestTypingsInstaller("/a/data/", /*throttleLimit*/5, host); } - return new TestSession(host, cancellationToken || server.nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ projectServiceEventHandler !== undefined, projectServiceEventHandler, throttleWaitMilliseconds); + const opts: server.SessionOptions = { + host, + cancellationToken: cancellationToken || server.nullCancellationToken, + useSingleInferredProject: false, + typingsInstaller, + byteLength: Utils.byteLength, + hrtime: process.hrtime, + logger: nullLogger, + canUseEvents: projectServiceEventHandler !== undefined, + eventHandler: projectServiceEventHandler, + throttleWaitMilliseconds + }; + return new TestSession(opts); } export interface CreateProjectServiceParameters { @@ -205,7 +217,9 @@ namespace ts.projectSystem { export class TestProjectService extends server.ProjectService { constructor(host: server.ServerHost, logger: server.Logger, cancellationToken: HostCancellationToken, useSingleInferredProject: boolean, typingsInstaller: server.ITypingsInstaller, eventHandler: server.ProjectServiceEventHandler) { - super(host, logger, cancellationToken, useSingleInferredProject, typingsInstaller, eventHandler); + super({ + host, logger, cancellationToken, useSingleInferredProject, typingsInstaller, eventHandler + }); } checkNumberOfProjects(count: { inferredProjects?: number, configuredProjects?: number, externalProjects?: number }) { diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts index 28d18ad5577..f4f1e66e1ff 100644 --- a/src/server/editorServices.ts +++ b/src/server/editorServices.ts @@ -273,6 +273,18 @@ namespace ts.server { } } + export interface ProjectServiceOptions { + host: ServerHost; + logger: Logger; + cancellationToken: HostCancellationToken; + useSingleInferredProject: boolean; + typingsInstaller: ITypingsInstaller; + eventHandler?: ProjectServiceEventHandler; + throttleWaitMilliseconds?: number; + globalPlugins?: string[]; + pluginProbeLocations?: string[]; + } + export class ProjectService { public readonly typingsCache: TypingsCache; @@ -320,19 +332,33 @@ namespace ts.server { public lastDeletedFile: ScriptInfo; - constructor(public readonly host: ServerHost, - public readonly logger: Logger, - public readonly cancellationToken: HostCancellationToken, - public readonly useSingleInferredProject: boolean, - readonly typingsInstaller: ITypingsInstaller = nullTypingsInstaller, - private readonly eventHandler?: ProjectServiceEventHandler, - public readonly throttleWaitMilliseconds?: number) { + public readonly host: ServerHost; + public readonly logger: Logger; + public readonly cancellationToken: HostCancellationToken; + public readonly useSingleInferredProject: boolean; + public readonly typingsInstaller: ITypingsInstaller; + public readonly throttleWaitMilliseconds?: number; + private readonly eventHandler?: ProjectServiceEventHandler; - Debug.assert(!!host.createHash, "'ServerHost.createHash' is required for ProjectService"); + public readonly globalPlugins: ReadonlyArray; + public readonly pluginProbeLocations: ReadonlyArray; - this.toCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames); + constructor(opts: ProjectServiceOptions) { + this.host = opts.host; + this.logger = opts.logger; + this.cancellationToken = opts.cancellationToken; + this.useSingleInferredProject = opts.useSingleInferredProject; + this.typingsInstaller = opts.typingsInstaller || nullTypingsInstaller; + this.throttleWaitMilliseconds = opts.throttleWaitMilliseconds; + this.eventHandler = opts.eventHandler; + this.globalPlugins = opts.globalPlugins || emptyArray; + this.pluginProbeLocations = opts.pluginProbeLocations || emptyArray; + + Debug.assert(!!this.host.createHash, "'ServerHost.createHash' is required for ProjectService"); + + this.toCanonicalFileName = createGetCanonicalFileName(this.host.useCaseSensitiveFileNames); this.directoryWatchers = new DirectoryWatchers(this); - this.throttledOperations = new ThrottledOperations(host); + this.throttledOperations = new ThrottledOperations(this.host); this.typingsInstaller.attach(this); @@ -344,7 +370,7 @@ namespace ts.server { extraFileExtensions: [] }; - this.documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames, host.getCurrentDirectory()); + this.documentRegistry = createDocumentRegistry(this.host.useCaseSensitiveFileNames, this.host.getCurrentDirectory()); } /* @internal */ diff --git a/src/server/project.ts b/src/server/project.ts index e57e605d65b..b79df827b6b 100644 --- a/src/server/project.ts +++ b/src/server/project.ts @@ -843,7 +843,7 @@ namespace ts.server { /** Used for configured projects which may have multiple open roots */ openRefCount = 0; - constructor(private configFileName: NormalizedPath, + constructor(configFileName: NormalizedPath, projectService: ProjectService, documentRegistry: ts.DocumentRegistry, hasExplicitListOfFiles: boolean, @@ -863,9 +863,6 @@ namespace ts.server { enablePlugins() { const host = this.projectService.host; const options = this.getCompilerOptions(); - const log = (message: string) => { - this.projectService.logger.info(message); - }; if (!(options.plugins && options.plugins.length)) { this.projectService.logger.info("No plugins exist"); @@ -878,13 +875,34 @@ namespace ts.server { return; } + // Search our peer node_modules, then any globally-specified probe paths + // ../../.. to walk from X/node_modules/typescript/lib/tsserver.js to X/node_modules/ + const searchPaths = [combinePaths(host.getExecutingFilePath(), "../../.."), ...this.projectService.pluginProbeLocations]; + + // Enable tsconfig-specified plugins for (const pluginConfigEntry of options.plugins) { - const searchPath = getDirectoryPath(this.configFileName); - const resolvedModule = Project.resolveModule(pluginConfigEntry.name, searchPath, host, log); + this.enablePlugin(pluginConfigEntry, searchPaths); + } + // Enable global plugins with synthetic configuration entries + for (const globalPluginName of this.projectService.globalPlugins) { + // Provide global: true so plugins can detect why they can't find their config + this.enablePlugin({ name: globalPluginName, global: true } as PluginImport, searchPaths); + } + } + + private enablePlugin(pluginConfigEntry: PluginImport, searchPaths: string[]) { + const log = (message: string) => { + this.projectService.logger.info(message); + }; + + for (const searchPath of searchPaths) { + const resolvedModule = Project.resolveModule(pluginConfigEntry.name, searchPath, this.projectService.host, log); if (resolvedModule) { this.enableProxy(resolvedModule, pluginConfigEntry); + return; } } + this.projectService.logger.info(`Couldn't find ${pluginConfigEntry.name} anywhere in paths: ${searchPaths.join(",")}`); } private enableProxy(pluginModuleFactory: PluginModuleFactory, configEntry: PluginImport) { diff --git a/src/server/server.ts b/src/server/server.ts index 704193210e3..433c7e16ab1 100644 --- a/src/server/server.ts +++ b/src/server/server.ts @@ -3,6 +3,20 @@ /// namespace ts.server { + interface IOSessionOptions { + host: ServerHost; + cancellationToken: ServerCancellationToken; + canUseEvents: boolean; + installerEventPort: number; + useSingleInferredProject: boolean; + disableAutomaticTypingAcquisition: boolean; + globalTypingsCacheLocation: string; + logger: Logger; + typingSafeListLocation: string; + telemetryEnabled: boolean; + globalPlugins: string[]; + pluginProbeLocations: string[]; + } const net: { connect(options: { port: number }, onConnect?: () => void): NodeSocket @@ -373,34 +387,25 @@ namespace ts.server { } class IOSession extends Session { - constructor( - host: ServerHost, - cancellationToken: ServerCancellationToken, - installerEventPort: number, - canUseEvents: boolean, - useSingleInferredProject: boolean, - disableAutomaticTypingAcquisition: boolean, - globalTypingsCacheLocation: string, - typingSafeListLocation: string, - telemetryEnabled: boolean, - logger: server.Logger) { - const typingsInstaller = disableAutomaticTypingAcquisition - ? undefined - : new NodeTypingsInstaller(telemetryEnabled, logger, host, installerEventPort, globalTypingsCacheLocation, typingSafeListLocation, host.newLine); + constructor(options: IOSessionOptions) { + const { host, installerEventPort, globalTypingsCacheLocation, typingSafeListLocation, canUseEvents } = options; + const typingsInstaller = disableAutomaticTypingAcquisition + ? undefined + : new NodeTypingsInstaller(telemetryEnabled, logger, host, installerEventPort, globalTypingsCacheLocation, typingSafeListLocation, host.newLine); - super( - host, - cancellationToken, - useSingleInferredProject, - typingsInstaller || nullTypingsInstaller, - Buffer.byteLength, - process.hrtime, - logger, - canUseEvents); + super({ + host, + cancellationToken, + useSingleInferredProject, + typingsInstaller: typingsInstaller || nullTypingsInstaller, + byteLength: Buffer.byteLength, + hrtime: process.hrtime, + logger, + canUseEvents}); - if (telemetryEnabled && typingsInstaller) { - typingsInstaller.setTelemetrySender(this); - } + if (telemetryEnabled && typingsInstaller) { + typingsInstaller.setTelemetrySender(this); + } } exit() { @@ -735,21 +740,29 @@ namespace ts.server { const typingSafeListLocation = findArgument("--typingSafeListLocation"); + const globalPlugins = (findArgument("--globalPlugins") || "").split(","); + const pluginProbeLocations = (findArgument("--pluginProbeLocations") || "").split(","); + const useSingleInferredProject = hasArgument("--useSingleInferredProject"); const disableAutomaticTypingAcquisition = hasArgument("--disableAutomaticTypingAcquisition"); const telemetryEnabled = hasArgument(Arguments.EnableTelemetry); - const ioSession = new IOSession( - sys, + const options: IOSessionOptions = { + host: sys, cancellationToken, - eventPort, - /*canUseEvents*/ eventPort === undefined, + installerEventPort: eventPort, + canUseEvents: eventPort === undefined, useSingleInferredProject, disableAutomaticTypingAcquisition, - getGlobalTypingsCacheLocation(), + globalTypingsCacheLocation: getGlobalTypingsCacheLocation(), typingSafeListLocation, telemetryEnabled, - logger); + logger, + globalPlugins, + pluginProbeLocations + }; + + const ioSession = new IOSession(options); process.on("uncaughtException", function (err: Error) { ioSession.logError(err, "unknown"); }); diff --git a/src/server/session.ts b/src/server/session.ts index 26dbceece45..d4dc371b16b 100644 --- a/src/server/session.ts +++ b/src/server/session.ts @@ -319,6 +319,22 @@ namespace ts.server { } } + export interface SessionOptions { + host: ServerHost; + cancellationToken: ServerCancellationToken; + useSingleInferredProject: boolean; + typingsInstaller: ITypingsInstaller; + byteLength: (buf: string, encoding?: string) => number; + hrtime: (start?: number[]) => number[]; + logger: Logger; + canUseEvents: boolean; + eventHandler?: ProjectServiceEventHandler; + throttleWaitMilliseconds?: number; + + globalPlugins?: string[]; + pluginProbeLocations?: string[]; + } + export class Session implements EventSender { private readonly gcTimer: GcTimer; protected projectService: ProjectService; @@ -327,22 +343,29 @@ namespace ts.server { private currentRequestId: number; private errorCheck: MultistepOperation; - private eventHander: ProjectServiceEventHandler; + private eventHandler: ProjectServiceEventHandler; - constructor( - private host: ServerHost, - private readonly cancellationToken: ServerCancellationToken, - useSingleInferredProject: boolean, - protected readonly typingsInstaller: ITypingsInstaller, - private byteLength: (buf: string, encoding?: string) => number, - private hrtime: (start?: number[]) => number[], - protected logger: Logger, - protected readonly canUseEvents: boolean, - eventHandler?: ProjectServiceEventHandler, - private readonly throttleWaitMilliseconds?: number) { + private host: ServerHost; + private readonly cancellationToken: ServerCancellationToken; + protected readonly typingsInstaller: ITypingsInstaller; + private byteLength: (buf: string, encoding?: string) => number; + private hrtime: (start?: number[]) => number[]; + protected logger: Logger; + private canUseEvents: boolean; - this.eventHander = canUseEvents - ? eventHandler || (event => this.defaultEventHandler(event)) + constructor(opts: SessionOptions) { + this.host = opts.host; + this.cancellationToken = opts.cancellationToken; + this.typingsInstaller = opts.typingsInstaller; + this.byteLength = opts.byteLength; + this.hrtime = opts.hrtime; + this.logger = opts.logger; + this.canUseEvents = opts.canUseEvents; + + const { throttleWaitMilliseconds } = opts; + + this.eventHandler = this.canUseEvents + ? opts.eventHandler || (event => this.defaultEventHandler(event)) : undefined; const multistepOperationHost: MultistepOperationHost = { @@ -351,11 +374,22 @@ namespace ts.server { getServerHost: () => this.host, logError: (err, cmd) => this.logError(err, cmd), sendRequestCompletedEvent: requestId => this.sendRequestCompletedEvent(requestId), - isCancellationRequested: () => cancellationToken.isCancellationRequested() + isCancellationRequested: () => this.cancellationToken.isCancellationRequested() }; this.errorCheck = new MultistepOperation(multistepOperationHost); - this.projectService = new ProjectService(host, logger, cancellationToken, useSingleInferredProject, typingsInstaller, this.eventHander, this.throttleWaitMilliseconds); - this.gcTimer = new GcTimer(host, /*delay*/ 7000, logger); + const settings: ProjectServiceOptions = { + host: this.host, + logger: this.logger, + cancellationToken: this.cancellationToken, + useSingleInferredProject: opts.useSingleInferredProject, + typingsInstaller: this.typingsInstaller, + throttleWaitMilliseconds, + eventHandler: this.eventHandler, + globalPlugins: opts.globalPlugins, + pluginProbeLocations: opts.pluginProbeLocations + }; + this.projectService = new ProjectService(settings); + this.gcTimer = new GcTimer(this.host, /*delay*/ 7000, this.logger); } private sendRequestCompletedEvent(requestId: number): void { @@ -947,8 +981,8 @@ namespace ts.server { */ private openClientFile(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind) { const { configFileName, configFileErrors } = this.projectService.openClientFileWithNormalizedPath(fileName, fileContent, scriptKind); - if (this.eventHander) { - this.eventHander({ + if (this.eventHandler) { + this.eventHandler({ eventName: "configFileDiag", data: { triggerFile: fileName, configFileName, diagnostics: configFileErrors || [] } }); From 19ddc1e94a85eb5cd6bb941ede1900f3d1e3b910 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 13 Apr 2017 15:51:38 -0700 Subject: [PATCH 28/35] Avoid loading duplicate local+global plugins --- src/server/project.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/server/project.ts b/src/server/project.ts index b79df827b6b..83b65f880e7 100644 --- a/src/server/project.ts +++ b/src/server/project.ts @@ -885,6 +885,9 @@ namespace ts.server { } // Enable global plugins with synthetic configuration entries for (const globalPluginName of this.projectService.globalPlugins) { + // Skip already-locally-loaded plugins + if (options.plugins.some(p => p.name === globalPluginName)) continue; + // Provide global: true so plugins can detect why they can't find their config this.enablePlugin({ name: globalPluginName, global: true } as PluginImport, searchPaths); } From d31364c09c95abf23075be2df67c65c5e59e0ff9 Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 13 Apr 2017 16:02:24 -0700 Subject: [PATCH 29/35] Load global plugins even if no local ones exist --- src/server/project.ts | 29 ++++++++++++++--------------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/src/server/project.ts b/src/server/project.ts index 83b65f880e7..b92e8e84972 100644 --- a/src/server/project.ts +++ b/src/server/project.ts @@ -864,12 +864,6 @@ namespace ts.server { const host = this.projectService.host; const options = this.getCompilerOptions(); - if (!(options.plugins && options.plugins.length)) { - this.projectService.logger.info("No plugins exist"); - // No plugins - return; - } - if (!host.require) { this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded"); return; @@ -880,16 +874,21 @@ namespace ts.server { const searchPaths = [combinePaths(host.getExecutingFilePath(), "../../.."), ...this.projectService.pluginProbeLocations]; // Enable tsconfig-specified plugins - for (const pluginConfigEntry of options.plugins) { - this.enablePlugin(pluginConfigEntry, searchPaths); + if (options.plugins) { + for (const pluginConfigEntry of options.plugins) { + this.enablePlugin(pluginConfigEntry, searchPaths); + } } - // Enable global plugins with synthetic configuration entries - for (const globalPluginName of this.projectService.globalPlugins) { - // Skip already-locally-loaded plugins - if (options.plugins.some(p => p.name === globalPluginName)) continue; - - // Provide global: true so plugins can detect why they can't find their config - this.enablePlugin({ name: globalPluginName, global: true } as PluginImport, searchPaths); + + if (this.projectService.globalPlugins) { + // Enable global plugins with synthetic configuration entries + for (const globalPluginName of this.projectService.globalPlugins) { + // Skip already-locally-loaded plugins + if (options.plugins && options.plugins.some(p => p.name === globalPluginName)) continue; + + // Provide global: true so plugins can detect why they can't find their config + this.enablePlugin({ name: globalPluginName, global: true } as PluginImport, searchPaths); + } } } From a9c015a56af28d1f74068a65f347ddba2298cb44 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Thu, 13 Apr 2017 16:25:48 -0700 Subject: [PATCH 30/35] Fix #15184: Use `void` and not `undefined` for `this` parameter types in the library --- src/lib/es2015.core.d.ts | 20 +- src/lib/es2015.iterable.d.ts | 40 +- src/lib/es5.d.ts | 348 +++++++-------- tests/baselines/reference/2dArrays.types | 6 +- .../anyInferenceAnonymousFunctions.types | 12 +- .../reference/argumentsAsPropertyName.types | 6 +- .../baselines/reference/arrayConcatMap.types | 6 +- tests/baselines/reference/arrayFilter.types | 6 +- .../baselines/reference/bestChoiceType.types | 18 +- ...eckSwitchStatementIfCaseTypeIsString.types | 6 +- ...classExpressionWithStaticProperties3.types | 6 +- ...ssExpressionWithStaticPropertiesES63.types | 6 +- ...commaOperatorInConditionalExpression.types | 6 +- .../reference/commentInMethodCall.types | 6 +- .../contextualSignatureInstantiation3.types | 12 +- .../reference/contextuallyTypedIife.types | 24 +- .../controlFlowDestructuringParameters.types | 6 +- .../reference/declarationEmitPromise.types | 12 +- tests/baselines/reference/enumIndexer.types | 6 +- tests/baselines/reference/genericArray1.types | 6 +- .../reference/genericInference1.types | 6 +- .../genericMethodOverspecialization.types | 18 +- .../implementArrayInterface.errors.txt | 4 +- .../baselines/reference/inferenceLimit.types | 4 +- .../inferentialTypingWithFunctionType2.types | 4 +- .../reference/keyofAndIndexedAccess.types | 6 +- .../reference/mapOnTupleTypes01.types | 54 +-- .../reference/mapOnTupleTypes02.types | 6 +- ...eLibrary_NoErrorDuplicateLibOptions1.types | 4 +- ...eLibrary_NoErrorDuplicateLibOptions2.types | 4 +- ...dularizeLibrary_TargetES5UsingES6Lib.types | 4 +- ...dularizeLibrary_TargetES6UsingES6Lib.types | 4 +- ...izeLibrary_UsingES5LibAndES6ArrayLib.types | 4 +- ...5LibES6ArrayLibES6WellknownSymbolLib.types | 4 +- tests/baselines/reference/nestedSelf.types | 6 +- ...yInContextuallyTypesFunctionParamter.types | 6 +- .../baselines/reference/objectRestForOf.types | 6 +- ...nParameterReferencedInObjectLiteral1.types | 10 +- ...cializationsShouldNotAffectEachOther.types | 10 +- .../baselines/reference/targetTypeArgs.types | 36 +- .../targetTypeObjectLiteralToAny.types | 6 +- ...peInNativeThisAssignableMethods.errors.txt | 409 ++++++++++++++++++ .../reference/tsxSpreadChildren.types | 6 +- ...lyReferencedTypeAliasToTypeLiteral01.types | 6 +- ...lyReferencedTypeAliasToTypeLiteral02.types | 6 +- tests/baselines/reference/typedArrays.types | 144 +++--- 46 files changed, 872 insertions(+), 463 deletions(-) create mode 100644 tests/baselines/reference/thisTypeInNativeThisAssignableMethods.errors.txt diff --git a/src/lib/es2015.core.d.ts b/src/lib/es2015.core.d.ts index 341fd80872c..283cf4917c5 100644 --- a/src/lib/es2015.core.d.ts +++ b/src/lib/es2015.core.d.ts @@ -10,8 +10,8 @@ interface Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean): T | undefined; - find(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean, thisArg: undefined): T | undefined; + find(predicate: (this: void, value: T, index: number, obj: Array) => boolean): T | undefined; + find(predicate: (this: void, value: T, index: number, obj: Array) => boolean, thisArg: undefined): T | undefined; find(predicate: (this: Z, value: T, index: number, obj: Array) => boolean, thisArg: Z): T | undefined; /** @@ -23,8 +23,8 @@ interface Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: void, value: T, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: void, value: T, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: T, index: number, obj: Array) => boolean, thisArg: Z): number; /** @@ -56,8 +56,8 @@ interface ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): Array; - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): Array; from(arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): Array; @@ -363,8 +363,8 @@ interface ReadonlyArray { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (this: undefined, value: T, index: number, obj: ReadonlyArray) => boolean): T | undefined; - find(predicate: (this: undefined, value: T, index: number, obj: ReadonlyArray) => boolean, thisArg: undefined): T | undefined; + find(predicate: (this: void, value: T, index: number, obj: ReadonlyArray) => boolean): T | undefined; + find(predicate: (this: void, value: T, index: number, obj: ReadonlyArray) => boolean, thisArg: undefined): T | undefined; find(predicate: (this: Z, value: T, index: number, obj: ReadonlyArray) => boolean, thisArg: Z): T | undefined; /** @@ -376,8 +376,8 @@ interface ReadonlyArray { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: T, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: void, value: T, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: void, value: T, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: T, index: number, obj: Array) => boolean, thisArg: Z): number; } diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts index 03c583dc155..e29b97e2d7b 100644 --- a/src/lib/es2015.iterable.d.ts +++ b/src/lib/es2015.iterable.d.ts @@ -54,8 +54,8 @@ interface ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): Array; - from(iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): Array; + from(iterable: Iterable, mapfn: (this: void, v: T, k: number) => U): Array; + from(iterable: Iterable, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): Array; from(iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): Array; /** @@ -182,8 +182,8 @@ interface Int8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int8Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; from(arrayLike: Iterable): Int8Array; @@ -218,8 +218,8 @@ interface Uint8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; from(arrayLike: Iterable): Uint8Array; @@ -257,8 +257,8 @@ interface Uint8ClampedArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; from(arrayLike: Iterable): Uint8ClampedArray; @@ -295,8 +295,8 @@ interface Int16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int16Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; from(arrayLike: Iterable): Int16Array; @@ -331,8 +331,8 @@ interface Uint16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint16Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; from(arrayLike: Iterable): Uint16Array; @@ -367,8 +367,8 @@ interface Int32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int32Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; from(arrayLike: Iterable): Int32Array; @@ -403,8 +403,8 @@ interface Uint32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint32Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; from(arrayLike: Iterable): Uint32Array; @@ -439,8 +439,8 @@ interface Float32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float32Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; from(arrayLike: Iterable): Float32Array; @@ -475,8 +475,8 @@ interface Float64ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; - from(arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float64Array; + from(arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; from(arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; from(arrayLike: Iterable): Float64Array; diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index b92d335457a..69460f40c16 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -1017,48 +1017,48 @@ interface ReadonlyArray { * @param callbackfn A function that accepts up to three arguments. The every method calls the callbackfn function for each element in array1 until the callbackfn returns false, or until the end of the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - every(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => boolean): boolean; - every(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => boolean, thisArg: undefined): boolean; + every(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => boolean): boolean; + every(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => boolean, thisArg: undefined): boolean; every(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray) => boolean, thisArg: Z): boolean; /** * Determines whether the specified callback function returns true for any element of an array. * @param callbackfn A function that accepts up to three arguments. The some method calls the callbackfn function for each element in array1 until the callbackfn returns true, or until the end of the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - some(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => boolean): boolean; - some(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => boolean, thisArg: undefined): boolean; + some(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => boolean): boolean; + some(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => boolean, thisArg: undefined): boolean; some(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray) => boolean, thisArg: Z): boolean; /** * Performs the specified action for each element in an array. * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => void): void; - forEach(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => void, thisArg: undefined): void; + forEach(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => void): void; + forEach(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => void, thisArg: undefined): void; forEach(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray) => void, thisArg: Z): void; /** * Calls a defined callback function on each element of an array, and returns an array that contains the results. * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => U): U[]; - map(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => U, thisArg: undefined): U[]; + map(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => U): U[]; + map(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => U, thisArg: undefined): U[]; map(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray) => U, thisArg: Z): U[]; /** * Returns the elements of an array that meet the condition specified in a callback function. * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => value is S): S[]; - filter(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => value is S, thisArg: undefined): S[]; + filter(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => value is S): S[]; + filter(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => value is S, thisArg: undefined): S[]; filter(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray) => value is S, thisArg: Z): S[]; /** * Returns the elements of an array that meet the condition specified in a callback function. * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => any): T[]; - filter(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray) => any, thisArg: undefined): T[]; + filter(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => any): T[]; + filter(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray) => any, thisArg: undefined): T[]; filter(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray) => any, thisArg: Z): T[]; /** * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. @@ -1176,72 +1176,72 @@ interface Array { * @param callbackfn A function that accepts up to three arguments. The every method calls the callbackfn function for each element in array1 until the callbackfn returns false, or until the end of the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - every(callbackfn: (this: undefined, value: T, index: number, array: T[]) => boolean): boolean; - every(callbackfn: (this: undefined, value: T, index: number, array: T[]) => boolean, thisArg: undefined): boolean; + every(callbackfn: (this: void, value: T, index: number, array: T[]) => boolean): boolean; + every(callbackfn: (this: void, value: T, index: number, array: T[]) => boolean, thisArg: undefined): boolean; every(callbackfn: (this: Z, value: T, index: number, array: T[]) => boolean, thisArg: Z): boolean; /** * Determines whether the specified callback function returns true for any element of an array. * @param callbackfn A function that accepts up to three arguments. The some method calls the callbackfn function for each element in array1 until the callbackfn returns true, or until the end of the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - some(callbackfn: (this: undefined, value: T, index: number, array: T[]) => boolean): boolean; - some(callbackfn: (this: undefined, value: T, index: number, array: T[]) => boolean, thisArg: undefined): boolean; + some(callbackfn: (this: void, value: T, index: number, array: T[]) => boolean): boolean; + some(callbackfn: (this: void, value: T, index: number, array: T[]) => boolean, thisArg: undefined): boolean; some(callbackfn: (this: Z, value: T, index: number, array: T[]) => boolean, thisArg: Z): boolean; /** * Performs the specified action for each element in an array. * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (this: undefined, value: T, index: number, array: T[]) => void): void; - forEach(callbackfn: (this: undefined, value: T, index: number, array: T[]) => void, thisArg: undefined): void; + forEach(callbackfn: (this: void, value: T, index: number, array: T[]) => void): void; + forEach(callbackfn: (this: void, value: T, index: number, array: T[]) => void, thisArg: undefined): void; forEach(callbackfn: (this: Z, value: T, index: number, array: T[]) => void, thisArg: Z): void; /** * Calls a defined callback function on each element of an array, and returns an array that contains the results. * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - map(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; - map(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; + map(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; + map(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; map(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; /** * Calls a defined callback function on each element of an array, and returns an array that contains the results. * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - map(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; - map(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; + map(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; + map(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; map(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; /** * Calls a defined callback function on each element of an array, and returns an array that contains the results. * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - map(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; - map(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; + map(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; + map(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; map(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; /** * Calls a defined callback function on each element of an array, and returns an array that contains the results. * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - map(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; - map(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; + map(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; + map(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; map(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; /** * Calls a defined callback function on each element of an array, and returns an array that contains the results. * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; - map(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; + map(callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; + map(callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; map(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; /** * Returns the elements of an array that meet the condition specified in a callback function. * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: T, index: number, array: T[]) => any): T[]; - filter(callbackfn: (this: undefined, value: T, index: number, array: T[]) => any, thisArg: undefined): T[]; + filter(callbackfn: (this: void, value: T, index: number, array: T[]) => any): T[]; + filter(callbackfn: (this: void, value: T, index: number, array: T[]) => any, thisArg: undefined): T[]; filter(callbackfn: (this: Z, value: T, index: number, array: T[]) => any, thisArg: Z): T[]; /** * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. @@ -1587,8 +1587,8 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - every(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => boolean): boolean; - every(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => boolean, thisArg: undefined): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean, thisArg: undefined): boolean; every(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => boolean, thisArg: Z): boolean; /** @@ -1608,8 +1608,8 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => any): Int8Array; - filter(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => any, thisArg: undefined): Int8Array; + filter(callbackfn: (this: void, value: number, index: number, array: Int8Array) => any): Int8Array; + filter(callbackfn: (this: void, value: number, index: number, array: Int8Array) => any, thisArg: undefined): Int8Array; filter(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => any, thisArg: Z): Int8Array; /** @@ -1621,8 +1621,8 @@ interface Int8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number | undefined; - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; find(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number | undefined; /** @@ -1634,8 +1634,8 @@ interface Int8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number; /** @@ -1645,8 +1645,8 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => void): void; - forEach(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => void, thisArg: undefined): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Int8Array) => void): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Int8Array) => void, thisArg: undefined): void; forEach(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => void, thisArg: Z): void; /** @@ -1685,8 +1685,8 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => number): Int8Array; - map(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => number, thisArg: undefined): Int8Array; + map(callbackfn: (this: void, value: number, index: number, array: Int8Array) => number): Int8Array; + map(callbackfn: (this: void, value: number, index: number, array: Int8Array) => number, thisArg: undefined): Int8Array; map(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => number, thisArg: Z): Int8Array; /** @@ -1771,8 +1771,8 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - some(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => boolean): boolean; - some(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => boolean, thisArg: undefined): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean, thisArg: undefined): boolean; some(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => boolean, thisArg: Z): boolean; /** @@ -1825,8 +1825,8 @@ interface Int8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int8Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; from(arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; from(arrayLike: ArrayLike): Int8Array; @@ -1878,8 +1878,8 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - every(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => boolean): boolean; - every(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => boolean, thisArg: undefined): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean, thisArg: undefined): boolean; every(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => boolean, thisArg: Z): boolean; /** @@ -1899,8 +1899,8 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => any): Uint8Array; - filter(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => any, thisArg: undefined): Uint8Array; + filter(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => any): Uint8Array; + filter(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => any, thisArg: undefined): Uint8Array; filter(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => any, thisArg: Z): Uint8Array; /** @@ -1912,8 +1912,8 @@ interface Uint8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number | undefined; - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; find(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number | undefined; /** @@ -1925,8 +1925,8 @@ interface Uint8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number; /** @@ -1936,8 +1936,8 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => void): void; - forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => void, thisArg: undefined): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => void): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => void, thisArg: undefined): void; forEach(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => void, thisArg: Z): void; /** @@ -1976,8 +1976,8 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => number): Uint8Array; - map(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => number, thisArg: undefined): Uint8Array; + map(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => number): Uint8Array; + map(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => number, thisArg: undefined): Uint8Array; map(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => number, thisArg: Z): Uint8Array; /** @@ -2062,8 +2062,8 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - some(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => boolean): boolean; - some(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => boolean, thisArg: undefined): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean, thisArg: undefined): boolean; some(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => boolean, thisArg: Z): boolean; /** @@ -2117,8 +2117,8 @@ interface Uint8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; from(arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; from(arrayLike: ArrayLike): Uint8Array; @@ -2170,8 +2170,8 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - every(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => boolean): boolean; - every(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: undefined): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: undefined): boolean; every(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: Z): boolean; /** @@ -2191,8 +2191,8 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => any): Uint8ClampedArray; - filter(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => any, thisArg: undefined): Uint8ClampedArray; + filter(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => any): Uint8ClampedArray; + filter(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => any, thisArg: undefined): Uint8ClampedArray; filter(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => any, thisArg: Z): Uint8ClampedArray; /** @@ -2204,8 +2204,8 @@ interface Uint8ClampedArray { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number | undefined; - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; find(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number | undefined; /** @@ -2217,8 +2217,8 @@ interface Uint8ClampedArray { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number; /** @@ -2228,8 +2228,8 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => void): void; - forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => void, thisArg: undefined): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => void): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => void, thisArg: undefined): void; forEach(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => void, thisArg: Z): void; /** @@ -2268,8 +2268,8 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => number): Uint8ClampedArray; - map(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => number, thisArg: undefined): Uint8ClampedArray; + map(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => number): Uint8ClampedArray; + map(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => number, thisArg: undefined): Uint8ClampedArray; map(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => number, thisArg: Z): Uint8ClampedArray; /** @@ -2354,8 +2354,8 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - some(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => boolean): boolean; - some(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: undefined): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: undefined): boolean; some(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: Z): boolean; /** @@ -2409,8 +2409,8 @@ interface Uint8ClampedArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; from(arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; from(arrayLike: ArrayLike): Uint8ClampedArray; @@ -2461,8 +2461,8 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - every(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => boolean): boolean; - every(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => boolean, thisArg: undefined): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean, thisArg: undefined): boolean; every(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => boolean, thisArg: Z): boolean; /** @@ -2482,8 +2482,8 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => any): Int16Array; - filter(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => any, thisArg: undefined): Int16Array; + filter(callbackfn: (this: void, value: number, index: number, array: Int16Array) => any): Int16Array; + filter(callbackfn: (this: void, value: number, index: number, array: Int16Array) => any, thisArg: undefined): Int16Array; filter(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => any, thisArg: Z): Int16Array; /** @@ -2495,8 +2495,8 @@ interface Int16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number | undefined; - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; find(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number | undefined; /** @@ -2508,8 +2508,8 @@ interface Int16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number; /** @@ -2519,8 +2519,8 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => void): void; - forEach(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => void, thisArg: undefined): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Int16Array) => void): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Int16Array) => void, thisArg: undefined): void; forEach(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => void, thisArg: Z): void; /** @@ -2559,8 +2559,8 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => number): Int16Array; - map(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => number, thisArg: undefined): Int16Array; + map(callbackfn: (this: void, value: number, index: number, array: Int16Array) => number): Int16Array; + map(callbackfn: (this: void, value: number, index: number, array: Int16Array) => number, thisArg: undefined): Int16Array; map(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => number, thisArg: Z): Int16Array; /** @@ -2645,8 +2645,8 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - some(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => boolean): boolean; - some(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => boolean, thisArg: undefined): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean, thisArg: undefined): boolean; some(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => boolean, thisArg: Z): boolean; /** @@ -2700,8 +2700,8 @@ interface Int16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int16Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; from(arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; from(arrayLike: ArrayLike): Int16Array; @@ -2753,8 +2753,8 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - every(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => boolean): boolean; - every(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => boolean, thisArg: undefined): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean, thisArg: undefined): boolean; every(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => boolean, thisArg: Z): boolean; /** @@ -2774,8 +2774,8 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => any): Uint16Array; - filter(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => any, thisArg: undefined): Uint16Array; + filter(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => any): Uint16Array; + filter(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => any, thisArg: undefined): Uint16Array; filter(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => any, thisArg: Z): Uint16Array; /** @@ -2787,8 +2787,8 @@ interface Uint16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number | undefined; - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; find(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number | undefined; /** @@ -2800,8 +2800,8 @@ interface Uint16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number; /** @@ -2811,8 +2811,8 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => void): void; - forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => void, thisArg: undefined): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => void): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => void, thisArg: undefined): void; forEach(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => void, thisArg: Z): void; /** @@ -2851,8 +2851,8 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => number): Uint16Array; - map(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => number, thisArg: undefined): Uint16Array; + map(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => number): Uint16Array; + map(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => number, thisArg: undefined): Uint16Array; map(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => number, thisArg: Z): Uint16Array; /** @@ -2937,8 +2937,8 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - some(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => boolean): boolean; - some(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => boolean, thisArg: undefined): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean, thisArg: undefined): boolean; some(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => boolean, thisArg: Z): boolean; /** @@ -2992,8 +2992,8 @@ interface Uint16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint16Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; from(arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; from(arrayLike: ArrayLike): Uint16Array; @@ -3044,8 +3044,8 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - every(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => boolean): boolean; - every(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => boolean, thisArg: undefined): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean, thisArg: undefined): boolean; every(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => boolean, thisArg: Z): boolean; /** @@ -3065,8 +3065,8 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => any): Int32Array; - filter(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => any, thisArg: undefined): Int32Array; + filter(callbackfn: (this: void, value: number, index: number, array: Int32Array) => any): Int32Array; + filter(callbackfn: (this: void, value: number, index: number, array: Int32Array) => any, thisArg: undefined): Int32Array; filter(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => any, thisArg: Z): Int32Array; /** @@ -3078,8 +3078,8 @@ interface Int32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number | undefined; - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; find(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number | undefined; /** @@ -3091,8 +3091,8 @@ interface Int32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number; /** @@ -3102,8 +3102,8 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => void): void; - forEach(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => void, thisArg: undefined): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Int32Array) => void): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Int32Array) => void, thisArg: undefined): void; forEach(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => void, thisArg: Z): void; /** @@ -3142,8 +3142,8 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => number): Int32Array; - map(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => number, thisArg: undefined): Int32Array; + map(callbackfn: (this: void, value: number, index: number, array: Int32Array) => number): Int32Array; + map(callbackfn: (this: void, value: number, index: number, array: Int32Array) => number, thisArg: undefined): Int32Array; map(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => number, thisArg: Z): Int32Array; /** @@ -3228,8 +3228,8 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - some(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => boolean): boolean; - some(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => boolean, thisArg: undefined): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean, thisArg: undefined): boolean; some(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => boolean, thisArg: Z): boolean; /** @@ -3283,8 +3283,8 @@ interface Int32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int32Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; from(arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; from(arrayLike: ArrayLike): Int32Array; @@ -3335,8 +3335,8 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - every(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => boolean): boolean; - every(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => boolean, thisArg: undefined): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean, thisArg: undefined): boolean; every(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => boolean, thisArg: Z): boolean; /** @@ -3356,8 +3356,8 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => any): Uint32Array; - filter(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => any, thisArg: undefined): Uint32Array; + filter(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => any): Uint32Array; + filter(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => any, thisArg: undefined): Uint32Array; filter(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => any, thisArg: Z): Uint32Array; /** @@ -3369,8 +3369,8 @@ interface Uint32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number | undefined; - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; find(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number | undefined; /** @@ -3382,8 +3382,8 @@ interface Uint32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number; /** @@ -3393,8 +3393,8 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => void): void; - forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => void, thisArg: undefined): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => void): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => void, thisArg: undefined): void; forEach(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => void, thisArg: Z): void; /** @@ -3433,8 +3433,8 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => number): Uint32Array; - map(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => number, thisArg: undefined): Uint32Array; + map(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => number): Uint32Array; + map(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => number, thisArg: undefined): Uint32Array; map(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => number, thisArg: Z): Uint32Array; /** @@ -3519,8 +3519,8 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - some(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => boolean): boolean; - some(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => boolean, thisArg: undefined): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean, thisArg: undefined): boolean; some(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => boolean, thisArg: Z): boolean; /** @@ -3574,8 +3574,8 @@ interface Uint32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint32Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; from(arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; from(arrayLike: ArrayLike): Uint32Array; @@ -3626,8 +3626,8 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - every(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => boolean): boolean; - every(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => boolean, thisArg: undefined): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean, thisArg: undefined): boolean; every(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => boolean, thisArg: Z): boolean; /** @@ -3647,8 +3647,8 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => any): Float32Array; - filter(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => any, thisArg: undefined): Float32Array; + filter(callbackfn: (this: void, value: number, index: number, array: Float32Array) => any): Float32Array; + filter(callbackfn: (this: void, value: number, index: number, array: Float32Array) => any, thisArg: undefined): Float32Array; filter(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => any, thisArg: Z): Float32Array; /** @@ -3660,8 +3660,8 @@ interface Float32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number | undefined; - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; find(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number | undefined; /** @@ -3673,8 +3673,8 @@ interface Float32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number; /** @@ -3684,8 +3684,8 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => void): void; - forEach(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => void, thisArg: undefined): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Float32Array) => void): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Float32Array) => void, thisArg: undefined): void; forEach(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => void, thisArg: Z): void; /** @@ -3724,8 +3724,8 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => number): Float32Array; - map(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => number, thisArg: undefined): Float32Array; + map(callbackfn: (this: void, value: number, index: number, array: Float32Array) => number): Float32Array; + map(callbackfn: (this: void, value: number, index: number, array: Float32Array) => number, thisArg: undefined): Float32Array; map(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => number, thisArg: Z): Float32Array; /** @@ -3810,8 +3810,8 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - some(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => boolean): boolean; - some(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => boolean, thisArg: undefined): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean, thisArg: undefined): boolean; some(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => boolean, thisArg: Z): boolean; /** @@ -3865,8 +3865,8 @@ interface Float32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float32Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; from(arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; from(arrayLike: ArrayLike): Float32Array; @@ -3918,8 +3918,8 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - every(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => boolean): boolean; - every(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => boolean, thisArg: undefined): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean): boolean; + every(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean, thisArg: undefined): boolean; every(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => boolean, thisArg: Z): boolean; /** @@ -3939,8 +3939,8 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - filter(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => any): Float64Array; - filter(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => any, thisArg: undefined): Float64Array; + filter(callbackfn: (this: void, value: number, index: number, array: Float64Array) => any): Float64Array; + filter(callbackfn: (this: void, value: number, index: number, array: Float64Array) => any, thisArg: undefined): Float64Array; filter(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => any, thisArg: Z): Float64Array; /** @@ -3952,8 +3952,8 @@ interface Float64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number | undefined; - find(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number | undefined; + find(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number | undefined; find(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number | undefined; /** @@ -3965,8 +3965,8 @@ interface Float64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean): number; - findIndex(predicate: (this: undefined, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean): number; + findIndex(predicate: (this: void, value: number, index: number, obj: Array) => boolean, thisArg: undefined): number; findIndex(predicate: (this: Z, value: number, index: number, obj: Array) => boolean, thisArg: Z): number; /** @@ -3976,8 +3976,8 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => void): void; - forEach(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => void, thisArg: undefined): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Float64Array) => void): void; + forEach(callbackfn: (this: void, value: number, index: number, array: Float64Array) => void, thisArg: undefined): void; forEach(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => void, thisArg: Z): void; /** @@ -4016,8 +4016,8 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => number): Float64Array; - map(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => number, thisArg: undefined): Float64Array; + map(callbackfn: (this: void, value: number, index: number, array: Float64Array) => number): Float64Array; + map(callbackfn: (this: void, value: number, index: number, array: Float64Array) => number, thisArg: undefined): Float64Array; map(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => number, thisArg: Z): Float64Array; /** @@ -4102,8 +4102,8 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - some(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => boolean): boolean; - some(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => boolean, thisArg: undefined): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean): boolean; + some(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean, thisArg: undefined): boolean; some(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => boolean, thisArg: Z): boolean; /** @@ -4157,8 +4157,8 @@ interface Float64ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; - from(arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float64Array; + from(arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; from(arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; from(arrayLike: ArrayLike): Float64Array; diff --git a/tests/baselines/reference/2dArrays.types b/tests/baselines/reference/2dArrays.types index cd5ddc0efa5..45672187306 100644 --- a/tests/baselines/reference/2dArrays.types +++ b/tests/baselines/reference/2dArrays.types @@ -26,12 +26,12 @@ class Board { return this.ships.every(function (val) { return val.isSunk; }); >this.ships.every(function (val) { return val.isSunk; }) : boolean ->this.ships.every : { (callbackfn: (this: undefined, value: Ship, index: number, array: Ship[]) => boolean): boolean; (callbackfn: (this: undefined, value: Ship, index: number, array: Ship[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Ship, index: number, array: Ship[]) => boolean, thisArg: Z): boolean; } +>this.ships.every : { (callbackfn: (this: void, value: Ship, index: number, array: Ship[]) => boolean): boolean; (callbackfn: (this: void, value: Ship, index: number, array: Ship[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Ship, index: number, array: Ship[]) => boolean, thisArg: Z): boolean; } >this.ships : Ship[] >this : this >ships : Ship[] ->every : { (callbackfn: (this: undefined, value: Ship, index: number, array: Ship[]) => boolean): boolean; (callbackfn: (this: undefined, value: Ship, index: number, array: Ship[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Ship, index: number, array: Ship[]) => boolean, thisArg: Z): boolean; } ->function (val) { return val.isSunk; } : (this: undefined, val: Ship) => boolean +>every : { (callbackfn: (this: void, value: Ship, index: number, array: Ship[]) => boolean): boolean; (callbackfn: (this: void, value: Ship, index: number, array: Ship[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: Ship, index: number, array: Ship[]) => boolean, thisArg: Z): boolean; } +>function (val) { return val.isSunk; } : (this: void, val: Ship) => boolean >val : Ship >val.isSunk : boolean >val : Ship diff --git a/tests/baselines/reference/anyInferenceAnonymousFunctions.types b/tests/baselines/reference/anyInferenceAnonymousFunctions.types index ee176215421..b015d350760 100644 --- a/tests/baselines/reference/anyInferenceAnonymousFunctions.types +++ b/tests/baselines/reference/anyInferenceAnonymousFunctions.types @@ -57,10 +57,10 @@ paired.reduce((b3, b4) => b3.concat({}), []); paired.map((c1) => c1.count); >paired.map((c1) => c1.count) : any[] ->paired.map : { (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } +>paired.map : { (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } >paired : any[] ->map : { (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } ->(c1) => c1.count : (this: undefined, c1: any) => any +>map : { (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } +>(c1) => c1.count : (this: void, c1: any) => any >c1 : any >c1.count : any >c1 : any @@ -68,10 +68,10 @@ paired.map((c1) => c1.count); paired.map(function (c2) { return c2.count; }); >paired.map(function (c2) { return c2.count; }) : any[] ->paired.map : { (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } +>paired.map : { (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } >paired : any[] ->map : { (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } ->function (c2) { return c2.count; } : (this: undefined, c2: any) => any +>map : { (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } +>function (c2) { return c2.count; } : (this: void, c2: any) => any >c2 : any >c2.count : any >c2 : any diff --git a/tests/baselines/reference/argumentsAsPropertyName.types b/tests/baselines/reference/argumentsAsPropertyName.types index 00773d2a3cf..73397199436 100644 --- a/tests/baselines/reference/argumentsAsPropertyName.types +++ b/tests/baselines/reference/argumentsAsPropertyName.types @@ -42,13 +42,13 @@ function myFunction(myType: MyType) { [1, 2, 3].forEach(function(j) { use(x); }) >[1, 2, 3].forEach(function(j) { use(x); }) : void ->[1, 2, 3].forEach : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; } +>[1, 2, 3].forEach : { (callbackfn: (this: void, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: void, value: number, index: number, array: number[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; } >[1, 2, 3] : number[] >1 : 1 >2 : 2 >3 : 3 ->forEach : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; } ->function(j) { use(x); } : (this: undefined, j: number) => void +>forEach : { (callbackfn: (this: void, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: void, value: number, index: number, array: number[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; } +>function(j) { use(x); } : (this: void, j: number) => void >j : number >use(x) : any >use : (s: any) => any diff --git a/tests/baselines/reference/arrayConcatMap.types b/tests/baselines/reference/arrayConcatMap.types index da4e998f92c..b234b7beb26 100644 --- a/tests/baselines/reference/arrayConcatMap.types +++ b/tests/baselines/reference/arrayConcatMap.types @@ -2,7 +2,7 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }]) >x : any[] >[].concat([{ a: 1 }], [{ a: 2 }]) .map(b => b.a) : any[] ->[].concat([{ a: 1 }], [{ a: 2 }]) .map : { (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } +>[].concat([{ a: 1 }], [{ a: 2 }]) .map : { (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } >[].concat([{ a: 1 }], [{ a: 2 }]) : any[] >[].concat : { (...items: any[][]): any[]; (...items: any[]): any[]; } >[] : undefined[] @@ -17,8 +17,8 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }]) >2 : 2 .map(b => b.a); ->map : { (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } ->b => b.a : (this: undefined, b: any) => any +>map : { (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } +>b => b.a : (this: void, b: any) => any >b : any >b.a : any >b : any diff --git a/tests/baselines/reference/arrayFilter.types b/tests/baselines/reference/arrayFilter.types index de11296f832..23ab4d915bd 100644 --- a/tests/baselines/reference/arrayFilter.types +++ b/tests/baselines/reference/arrayFilter.types @@ -22,10 +22,10 @@ var foo = [ foo.filter(x => x.name); //should accepted all possible types not only boolean! >foo.filter(x => x.name) : { name: string; }[] ->foo.filter : { (callbackfn: (this: undefined, value: { name: string; }, index: number, array: { name: string; }[]) => any): { name: string; }[]; (callbackfn: (this: undefined, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: undefined): { name: string; }[]; (callbackfn: (this: Z, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: Z): { name: string; }[]; } +>foo.filter : { (callbackfn: (this: void, value: { name: string; }, index: number, array: { name: string; }[]) => any): { name: string; }[]; (callbackfn: (this: void, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: undefined): { name: string; }[]; (callbackfn: (this: Z, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: Z): { name: string; }[]; } >foo : { name: string; }[] ->filter : { (callbackfn: (this: undefined, value: { name: string; }, index: number, array: { name: string; }[]) => any): { name: string; }[]; (callbackfn: (this: undefined, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: undefined): { name: string; }[]; (callbackfn: (this: Z, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: Z): { name: string; }[]; } ->x => x.name : (this: undefined, x: { name: string; }) => string +>filter : { (callbackfn: (this: void, value: { name: string; }, index: number, array: { name: string; }[]) => any): { name: string; }[]; (callbackfn: (this: void, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: undefined): { name: string; }[]; (callbackfn: (this: Z, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: Z): { name: string; }[]; } +>x => x.name : (this: void, x: { name: string; }) => string >x : { name: string; } >x.name : string >x : { name: string; } diff --git a/tests/baselines/reference/bestChoiceType.types b/tests/baselines/reference/bestChoiceType.types index c4728de2ff1..15c5ecd4858 100644 --- a/tests/baselines/reference/bestChoiceType.types +++ b/tests/baselines/reference/bestChoiceType.types @@ -3,7 +3,7 @@ (''.match(/ /) || []).map(s => s.toLowerCase()); >(''.match(/ /) || []).map(s => s.toLowerCase()) : string[] ->(''.match(/ /) || []).map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>(''.match(/ /) || []).map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } >(''.match(/ /) || []) : RegExpMatchArray >''.match(/ /) || [] : RegExpMatchArray >''.match(/ /) : RegExpMatchArray | null @@ -12,8 +12,8 @@ >match : (regexp: string | RegExp) => RegExpMatchArray | null >/ / : RegExp >[] : never[] ->map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } ->s => s.toLowerCase() : (this: undefined, s: string) => string +>map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>s => s.toLowerCase() : (this: void, s: string) => string >s : string >s.toLowerCase() : string >s.toLowerCase : () => string @@ -42,10 +42,10 @@ function f1() { let z = y.map(s => s.toLowerCase()); >z : string[] >y.map(s => s.toLowerCase()) : string[] ->y.map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>y.map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } >y : RegExpMatchArray ->map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } ->s => s.toLowerCase() : (this: undefined, s: string) => string +>map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>s => s.toLowerCase() : (this: void, s: string) => string >s : string >s.toLowerCase() : string >s.toLowerCase : () => string @@ -74,10 +74,10 @@ function f2() { let z = y.map(s => s.toLowerCase()); >z : string[] >y.map(s => s.toLowerCase()) : string[] ->y.map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>y.map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } >y : RegExpMatchArray ->map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } ->s => s.toLowerCase() : (this: undefined, s: string) => string +>map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>s => s.toLowerCase() : (this: void, s: string) => string >s : string >s.toLowerCase() : string >s.toLowerCase : () => string diff --git a/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types b/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types index 7bae17fb922..115930df20a 100644 --- a/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types +++ b/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types @@ -13,10 +13,10 @@ class A { x.forEach((v) => { >x.forEach((v) => { switch(v) { case "test": use(this); } }) : void ->x.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>x.forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } >x : string[] ->forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } ->(v) => { switch(v) { case "test": use(this); } } : (this: undefined, v: string) => void +>forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>(v) => { switch(v) { case "test": use(this); } } : (this: void, v: string) => void >v : string switch(v) { diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.types b/tests/baselines/reference/classExpressionWithStaticProperties3.types index ff2871e4d94..6f598e6e42e 100644 --- a/tests/baselines/reference/classExpressionWithStaticProperties3.types +++ b/tests/baselines/reference/classExpressionWithStaticProperties3.types @@ -41,10 +41,10 @@ for (let i = 0; i < 3; i++) { } arr.forEach(C => console.log(C.y())); >arr.forEach(C => console.log(C.y())) : void ->arr.forEach : { (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; } +>arr.forEach : { (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; } >arr : { y(): number; }[] ->forEach : { (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; } ->C => console.log(C.y()) : (this: undefined, C: { y(): number; }) => any +>forEach : { (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; } +>C => console.log(C.y()) : (this: void, C: { y(): number; }) => any >C : { y(): number; } >console.log(C.y()) : any >console.log : any diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types index da771990ee9..b5cd81e8590 100644 --- a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types +++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types @@ -41,10 +41,10 @@ for (let i = 0; i < 3; i++) { } arr.forEach(C => console.log(C.y())); >arr.forEach(C => console.log(C.y())) : void ->arr.forEach : { (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; } +>arr.forEach : { (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; } >arr : { y(): number; }[] ->forEach : { (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; } ->C => console.log(C.y()) : (this: undefined, C: { y(): number; }) => any +>forEach : { (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; } +>C => console.log(C.y()) : (this: void, C: { y(): number; }) => any >C : { y(): number; } >console.log(C.y()) : any >console.log : any diff --git a/tests/baselines/reference/commaOperatorInConditionalExpression.types b/tests/baselines/reference/commaOperatorInConditionalExpression.types index de8a95cd6c3..7ee2ab72c77 100644 --- a/tests/baselines/reference/commaOperatorInConditionalExpression.types +++ b/tests/baselines/reference/commaOperatorInConditionalExpression.types @@ -5,13 +5,13 @@ function f (m: string) { [1, 2, 3].map(i => { >[1, 2, 3].map(i => { return true? { [m]: i } : { [m]: i + 1 } }) : { [x: string]: number; }[] ->[1, 2, 3].map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>[1, 2, 3].map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >[1, 2, 3] : number[] >1 : 1 >2 : 2 >3 : 3 ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } ->i => { return true? { [m]: i } : { [m]: i + 1 } } : (this: undefined, i: number) => { [x: string]: number; } +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>i => { return true? { [m]: i } : { [m]: i + 1 } } : (this: void, i: number) => { [x: string]: number; } >i : number return true? { [m]: i } : { [m]: i + 1 } diff --git a/tests/baselines/reference/commentInMethodCall.types b/tests/baselines/reference/commentInMethodCall.types index eebbc15823e..b74323d1477 100644 --- a/tests/baselines/reference/commentInMethodCall.types +++ b/tests/baselines/reference/commentInMethodCall.types @@ -5,10 +5,10 @@ var s: string[]; s.map(// do something >s.map(// do something function () { }) : void[] ->s.map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>s.map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } >s : string[] ->map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } function () { }); ->function () { } : (this: undefined) => void +>function () { } : (this: void) => void diff --git a/tests/baselines/reference/contextualSignatureInstantiation3.types b/tests/baselines/reference/contextualSignatureInstantiation3.types index dcb7284ceaa..60ad7c31bf6 100644 --- a/tests/baselines/reference/contextualSignatureInstantiation3.types +++ b/tests/baselines/reference/contextualSignatureInstantiation3.types @@ -13,9 +13,9 @@ function map(items: T[], f: (x: T) => U): U[]{ return items.map(f); >items.map(f) : U[] ->items.map : { (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; } +>items.map : { (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; } >items : T[] ->map : { (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; } +>map : { (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; } >f : (x: T) => U } @@ -54,9 +54,9 @@ var v1: number[]; var v1 = xs.map(identity); // Error if not number[] >v1 : number[] >xs.map(identity) : number[] ->xs.map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>xs.map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >xs : number[] ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >identity : (x: T) => T var v1 = map(xs, identity); // Error if not number[] @@ -72,9 +72,9 @@ var v2: number[][]; var v2 = xs.map(singleton); // Error if not number[][] >v2 : number[][] >xs.map(singleton) : number[][] ->xs.map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>xs.map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >xs : number[] ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >singleton : (x: T) => T[] var v2 = map(xs, singleton); // Error if not number[][] diff --git a/tests/baselines/reference/contextuallyTypedIife.types b/tests/baselines/reference/contextuallyTypedIife.types index b8c59a618b8..04ddbf50fde 100644 --- a/tests/baselines/reference/contextuallyTypedIife.types +++ b/tests/baselines/reference/contextuallyTypedIife.types @@ -105,10 +105,10 @@ >(...numbers) => numbers.every(n => n > 0) : (...numbers: number[]) => boolean >numbers : number[] >numbers.every(n => n > 0) : boolean ->numbers.every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } +>numbers.every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } >numbers : number[] ->every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } ->n => n > 0 : (this: undefined, n: number) => boolean +>every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } +>n => n > 0 : (this: void, n: number) => boolean >n : number >n > 0 : boolean >n : number @@ -123,10 +123,10 @@ >(...mixed) => mixed.every(n => !!n) : (...mixed: (string | number)[]) => boolean >mixed : (string | number)[] >mixed.every(n => !!n) : boolean ->mixed.every : { (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => boolean): boolean; (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: Z): boolean; } +>mixed.every : { (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => boolean): boolean; (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: Z): boolean; } >mixed : (string | number)[] ->every : { (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => boolean): boolean; (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: Z): boolean; } ->n => !!n : (this: undefined, n: string | number) => boolean +>every : { (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => boolean): boolean; (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: Z): boolean; } +>n => !!n : (this: void, n: string | number) => boolean >n : string | number >!!n : boolean >!n : boolean @@ -141,10 +141,10 @@ >(...noNumbers) => noNumbers.some(n => n > 0) : (...noNumbers: any[]) => boolean >noNumbers : any[] >noNumbers.some(n => n > 0) : boolean ->noNumbers.some : { (callbackfn: (this: undefined, value: any, index: number, array: any[]) => boolean): boolean; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: any, index: number, array: any[]) => boolean, thisArg: Z): boolean; } +>noNumbers.some : { (callbackfn: (this: void, value: any, index: number, array: any[]) => boolean): boolean; (callbackfn: (this: void, value: any, index: number, array: any[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: any, index: number, array: any[]) => boolean, thisArg: Z): boolean; } >noNumbers : any[] ->some : { (callbackfn: (this: undefined, value: any, index: number, array: any[]) => boolean): boolean; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: any, index: number, array: any[]) => boolean, thisArg: Z): boolean; } ->n => n > 0 : (this: undefined, n: any) => boolean +>some : { (callbackfn: (this: void, value: any, index: number, array: any[]) => boolean): boolean; (callbackfn: (this: void, value: any, index: number, array: any[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: any, index: number, array: any[]) => boolean, thisArg: Z): boolean; } +>n => n > 0 : (this: void, n: any) => boolean >n : any >n > 0 : boolean >n : any @@ -160,10 +160,10 @@ >first : number >[] : undefined[] >rest.map(n => n > 0) : boolean[] ->rest.map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>rest.map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >rest : number[] ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } ->n => n > 0 : (this: undefined, n: number) => boolean +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>n => n > 0 : (this: void, n: number) => boolean >n : number >n > 0 : boolean >n : number diff --git a/tests/baselines/reference/controlFlowDestructuringParameters.types b/tests/baselines/reference/controlFlowDestructuringParameters.types index d1adadfee17..7fdb1eded01 100644 --- a/tests/baselines/reference/controlFlowDestructuringParameters.types +++ b/tests/baselines/reference/controlFlowDestructuringParameters.types @@ -4,15 +4,15 @@ [{ x: 1 }].map( >[{ x: 1 }].map( ({ x }) => x) : number[] ->[{ x: 1 }].map : { (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): U[]; (callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): U[]; } +>[{ x: 1 }].map : { (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): U[]; (callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): U[]; } >[{ x: 1 }] : { x: number; }[] >{ x: 1 } : { x: number; } >x : number >1 : 1 ->map : { (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): U[]; (callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): U[]; } +>map : { (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): U[]; (callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): U[]; } ({ x }) => x ->({ x }) => x : (this: undefined, {x}: { x: number; }) => number +>({ x }) => x : (this: void, {x}: { x: number; }) => number >x : number >x : number diff --git a/tests/baselines/reference/declarationEmitPromise.types b/tests/baselines/reference/declarationEmitPromise.types index 70012094bf3..9fafbd0cbd6 100644 --- a/tests/baselines/reference/declarationEmitPromise.types +++ b/tests/baselines/reference/declarationEmitPromise.types @@ -44,15 +44,15 @@ export async function runSampleWorks( >bluebird : typeof bluebird >all : bluebird[] >[a, b, c, d, e].filter(el => !!el) : bluebird[] ->[a, b, c, d, e].filter : { (callbackfn: (this: undefined, value: bluebird, index: number, array: bluebird[]) => any): bluebird[]; (callbackfn: (this: undefined, value: bluebird, index: number, array: bluebird[]) => any, thisArg: undefined): bluebird[]; (callbackfn: (this: Z, value: bluebird, index: number, array: bluebird[]) => any, thisArg: Z): bluebird[]; } +>[a, b, c, d, e].filter : { (callbackfn: (this: void, value: bluebird, index: number, array: bluebird[]) => any): bluebird[]; (callbackfn: (this: void, value: bluebird, index: number, array: bluebird[]) => any, thisArg: undefined): bluebird[]; (callbackfn: (this: Z, value: bluebird, index: number, array: bluebird[]) => any, thisArg: Z): bluebird[]; } >[a, b, c, d, e] : bluebird[] >a : bluebird >b : bluebird >c : bluebird >d : bluebird >e : bluebird ->filter : { (callbackfn: (this: undefined, value: bluebird, index: number, array: bluebird[]) => any): bluebird[]; (callbackfn: (this: undefined, value: bluebird, index: number, array: bluebird[]) => any, thisArg: undefined): bluebird[]; (callbackfn: (this: Z, value: bluebird, index: number, array: bluebird[]) => any, thisArg: Z): bluebird[]; } ->el => !!el : (this: undefined, el: bluebird) => boolean +>filter : { (callbackfn: (this: void, value: bluebird, index: number, array: bluebird[]) => any): bluebird[]; (callbackfn: (this: void, value: bluebird, index: number, array: bluebird[]) => any, thisArg: undefined): bluebird[]; (callbackfn: (this: Z, value: bluebird, index: number, array: bluebird[]) => any, thisArg: Z): bluebird[]; } +>el => !!el : (this: void, el: bluebird) => boolean >el : bluebird >!!el : boolean >!el : boolean @@ -129,15 +129,15 @@ export async function runSampleBreaks( >bluebird : typeof bluebird >all : bluebird[] >[a, b, c, d, e].filter(el => !!el) : bluebird[] ->[a, b, c, d, e].filter : { (callbackfn: (this: undefined, value: bluebird, index: number, array: bluebird[]) => any): bluebird[]; (callbackfn: (this: undefined, value: bluebird, index: number, array: bluebird[]) => any, thisArg: undefined): bluebird[]; (callbackfn: (this: Z, value: bluebird, index: number, array: bluebird[]) => any, thisArg: Z): bluebird[]; } +>[a, b, c, d, e].filter : { (callbackfn: (this: void, value: bluebird, index: number, array: bluebird[]) => any): bluebird[]; (callbackfn: (this: void, value: bluebird, index: number, array: bluebird[]) => any, thisArg: undefined): bluebird[]; (callbackfn: (this: Z, value: bluebird, index: number, array: bluebird[]) => any, thisArg: Z): bluebird[]; } >[a, b, c, d, e] : bluebird[] >a : bluebird >b : bluebird >c : bluebird >d : bluebird >e : bluebird ->filter : { (callbackfn: (this: undefined, value: bluebird, index: number, array: bluebird[]) => any): bluebird[]; (callbackfn: (this: undefined, value: bluebird, index: number, array: bluebird[]) => any, thisArg: undefined): bluebird[]; (callbackfn: (this: Z, value: bluebird, index: number, array: bluebird[]) => any, thisArg: Z): bluebird[]; } ->el => !!el : (this: undefined, el: bluebird) => boolean +>filter : { (callbackfn: (this: void, value: bluebird, index: number, array: bluebird[]) => any): bluebird[]; (callbackfn: (this: void, value: bluebird, index: number, array: bluebird[]) => any, thisArg: undefined): bluebird[]; (callbackfn: (this: Z, value: bluebird, index: number, array: bluebird[]) => any, thisArg: Z): bluebird[]; } +>el => !!el : (this: void, el: bluebird) => boolean >el : bluebird >!!el : boolean >!el : boolean diff --git a/tests/baselines/reference/enumIndexer.types b/tests/baselines/reference/enumIndexer.types index 981ad5c8c81..eb4b4e18e76 100644 --- a/tests/baselines/reference/enumIndexer.types +++ b/tests/baselines/reference/enumIndexer.types @@ -25,10 +25,10 @@ var enumValue = MyEnumType.foo; var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same type >x : boolean[] >_arr.map(o => MyEnumType[o.key] === enumValue) : boolean[] ->_arr.map : { (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): U[]; (callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): U[]; } +>_arr.map : { (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): U[]; (callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): U[]; } >_arr : { key: string; }[] ->map : { (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): U[]; (callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): U[]; } ->o => MyEnumType[o.key] === enumValue : (this: undefined, o: { key: string; }) => boolean +>map : { (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): U[]; (callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): U[]; } +>o => MyEnumType[o.key] === enumValue : (this: void, o: { key: string; }) => boolean >o : { key: string; } >MyEnumType[o.key] === enumValue : boolean >MyEnumType[o.key] : any diff --git a/tests/baselines/reference/genericArray1.types b/tests/baselines/reference/genericArray1.types index b893d9778fc..bf5d55eb569 100644 --- a/tests/baselines/reference/genericArray1.types +++ b/tests/baselines/reference/genericArray1.types @@ -14,13 +14,13 @@ interface String{ var lengths = ["a", "b", "c"].map(x => x.length); >lengths : number[] >["a", "b", "c"].map(x => x.length) : number[] ->["a", "b", "c"].map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>["a", "b", "c"].map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } >["a", "b", "c"] : string[] >"a" : "a" >"b" : "b" >"c" : "c" ->map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } ->x => x.length : (this: undefined, x: string) => number +>map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>x => x.length : (this: void, x: string) => number >x : string >x.length : number >x : string diff --git a/tests/baselines/reference/genericInference1.types b/tests/baselines/reference/genericInference1.types index 64ff2c399cd..8995e07c825 100644 --- a/tests/baselines/reference/genericInference1.types +++ b/tests/baselines/reference/genericInference1.types @@ -1,13 +1,13 @@ === tests/cases/compiler/genericInference1.ts === ['a', 'b', 'c'].map(x => x.length); >['a', 'b', 'c'].map(x => x.length) : number[] ->['a', 'b', 'c'].map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>['a', 'b', 'c'].map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } >['a', 'b', 'c'] : string[] >'a' : "a" >'b' : "b" >'c' : "c" ->map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } ->x => x.length : (this: undefined, x: string) => number +>map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>x => x.length : (this: void, x: string) => number >x : string >x.length : number >x : string diff --git a/tests/baselines/reference/genericMethodOverspecialization.types b/tests/baselines/reference/genericMethodOverspecialization.types index 36b710b742c..17f3e0dddd7 100644 --- a/tests/baselines/reference/genericMethodOverspecialization.types +++ b/tests/baselines/reference/genericMethodOverspecialization.types @@ -34,10 +34,10 @@ interface Document { var elements = names.map(function (name) { >elements : HTMLElement[] >names.map(function (name) { return document.getElementById(name);}) : HTMLElement[] ->names.map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>names.map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } >names : string[] ->map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } ->function (name) { return document.getElementById(name);} : (this: undefined, name: string) => HTMLElement +>map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>function (name) { return document.getElementById(name);} : (this: void, name: string) => HTMLElement >name : string return document.getElementById(name); @@ -53,10 +53,10 @@ var elements = names.map(function (name) { var xxx = elements.filter(function (e) { >xxx : HTMLElement[] >elements.filter(function (e) { return !e.isDisabled;}) : HTMLElement[] ->elements.filter : { (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => any): HTMLElement[]; (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: undefined): HTMLElement[]; (callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: Z): HTMLElement[]; } +>elements.filter : { (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => any): HTMLElement[]; (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: undefined): HTMLElement[]; (callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: Z): HTMLElement[]; } >elements : HTMLElement[] ->filter : { (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => any): HTMLElement[]; (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: undefined): HTMLElement[]; (callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: Z): HTMLElement[]; } ->function (e) { return !e.isDisabled;} : (this: undefined, e: HTMLElement) => boolean +>filter : { (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => any): HTMLElement[]; (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: undefined): HTMLElement[]; (callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: Z): HTMLElement[]; } +>function (e) { return !e.isDisabled;} : (this: void, e: HTMLElement) => boolean >e : HTMLElement return !e.isDisabled; @@ -70,10 +70,10 @@ var xxx = elements.filter(function (e) { var widths:number[] = elements.map(function (e) { // should not error >widths : number[] >elements.map(function (e) { // should not error return e.clientWidth;}) : number[] ->elements.map : { (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): U[]; (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): U[]; } +>elements.map : { (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): U[]; (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): U[]; } >elements : HTMLElement[] ->map : { (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): U[]; (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): U[]; } ->function (e) { // should not error return e.clientWidth;} : (this: undefined, e: HTMLElement) => number +>map : { (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): U[]; (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): U[]; } +>function (e) { // should not error return e.clientWidth;} : (this: void, e: HTMLElement) => number >e : HTMLElement return e.clientWidth; diff --git a/tests/baselines/reference/implementArrayInterface.errors.txt b/tests/baselines/reference/implementArrayInterface.errors.txt index 139bb42105d..61c4440fa3a 100644 --- a/tests/baselines/reference/implementArrayInterface.errors.txt +++ b/tests/baselines/reference/implementArrayInterface.errors.txt @@ -1,6 +1,6 @@ tests/cases/compiler/implementArrayInterface.ts(1,15): error TS2420: Class 'MyArray' incorrectly implements interface 'T[]'. Types of property 'map' are incompatible. - Type '(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]' is not assignable to type '{ (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }'. + Type '(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]' is not assignable to type '{ (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }'. Type 'any[]' is not assignable to type '[any, any, any, any, any]'. Property '0' is missing in type 'any[]'. @@ -10,7 +10,7 @@ tests/cases/compiler/implementArrayInterface.ts(1,15): error TS2420: Class 'MyAr ~~~~~~~ !!! error TS2420: Class 'MyArray' incorrectly implements interface 'T[]'. !!! error TS2420: Types of property 'map' are incompatible. -!!! error TS2420: Type '(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]' is not assignable to type '{ (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }'. +!!! error TS2420: Type '(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]' is not assignable to type '{ (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }'. !!! error TS2420: Type 'any[]' is not assignable to type '[any, any, any, any, any]'. !!! error TS2420: Property '0' is missing in type 'any[]'. toString(): string; diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types index 9f2f11d988f..c7cb6d8333e 100644 --- a/tests/baselines/reference/inferenceLimit.types +++ b/tests/baselines/reference/inferenceLimit.types @@ -84,9 +84,9 @@ export class BrokenClass { >Promise : PromiseConstructor >all : { (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike, T6 | PromiseLike, T7 | PromiseLike, T8 | PromiseLike, T9 | PromiseLike, T10 | PromiseLike]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike, T6 | PromiseLike, T7 | PromiseLike, T8 | PromiseLike, T9 | PromiseLike]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike, T6 | PromiseLike, T7 | PromiseLike, T8 | PromiseLike]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike, T6 | PromiseLike, T7 | PromiseLike]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike, T6 | PromiseLike]): Promise<[T1, T2, T3, T4, T5, T6]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike]): Promise<[T1, T2, T3, T4, T5]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike]): Promise<[T1, T2, T3, T4]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike]): Promise<[T1, T2, T3]>; (values: [T1 | PromiseLike, T2 | PromiseLike]): Promise<[T1, T2]>; (values: (T | PromiseLike)[]): Promise; (values: Iterable>): Promise; } >result.map(populateItems) : Promise<{}>[] ->result.map : { (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): U[]; (callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): U[]; } +>result.map : { (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): U[]; (callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): U[]; } >result : MyModule.MyModel[] ->map : { (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): U[]; (callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): U[]; } +>map : { (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): U[]; (callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): U[]; } >populateItems : (order: any) => Promise<{}> .then((orders: Array) => { diff --git a/tests/baselines/reference/inferentialTypingWithFunctionType2.types b/tests/baselines/reference/inferentialTypingWithFunctionType2.types index 55caace2c2c..90c84817922 100644 --- a/tests/baselines/reference/inferentialTypingWithFunctionType2.types +++ b/tests/baselines/reference/inferentialTypingWithFunctionType2.types @@ -13,12 +13,12 @@ var x = [1, 2, 3].map(identity)[0]; >x : number >[1, 2, 3].map(identity)[0] : number >[1, 2, 3].map(identity) : number[] ->[1, 2, 3].map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>[1, 2, 3].map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >[1, 2, 3] : number[] >1 : 1 >2 : 2 >3 : 3 ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >identity : (a: A) => A >0 : 0 diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types index 19ecac10188..a9698a47bd2 100644 --- a/tests/baselines/reference/keyofAndIndexedAccess.types +++ b/tests/baselines/reference/keyofAndIndexedAccess.types @@ -522,10 +522,10 @@ function pluck(array: T[], key: K) { return array.map(x => x[key]); >array.map(x => x[key]) : T[K][] ->array.map : { (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; } +>array.map : { (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; } >array : T[] ->map : { (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; } ->x => x[key] : (this: undefined, x: T) => T[K] +>map : { (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; (this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; (this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; (this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; (this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; (this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; (callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; } +>x => x[key] : (this: void, x: T) => T[K] >x : T >x[key] : T[K] >x : T diff --git a/tests/baselines/reference/mapOnTupleTypes01.types b/tests/baselines/reference/mapOnTupleTypes01.types index e55edda1124..72b6a6dbae1 100644 --- a/tests/baselines/reference/mapOnTupleTypes01.types +++ b/tests/baselines/reference/mapOnTupleTypes01.types @@ -2,14 +2,14 @@ export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); >mapOnLooseArrayLiteral : number[] >[1, 2, 3, 4].map(n => n * n) : number[] ->[1, 2, 3, 4].map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>[1, 2, 3, 4].map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >[1, 2, 3, 4] : number[] >1 : 1 >2 : 2 >3 : 3 >4 : 4 ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } ->n => n * n : (this: undefined, n: number) => number +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>n => n * n : (this: void, n: number) => number >n : number >n * n : number >n : number @@ -25,10 +25,10 @@ let numTuple: [number] = [1]; export let a = numTuple.map(x => x * x); >a : number[] >numTuple.map(x => x * x) : number[] ->numTuple.map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>numTuple.map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >numTuple : [number] ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } ->x => x * x : (this: undefined, x: number) => number +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>x => x * x : (this: void, x: number) => number >x : number >x * x : number >x : number @@ -57,10 +57,10 @@ let numStr: [number, string] = [ 100, "hello"]; export let b = numNum.map(n => n * n); >b : [number, number] >numNum.map(n => n * n) : [number, number] ->numNum.map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>numNum.map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >numNum : [number, number] ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } ->n => n * n : (this: undefined, n: number) => number +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>n => n * n : (this: void, n: number) => number >n : number >n * n : number >n : number @@ -69,10 +69,10 @@ export let b = numNum.map(n => n * n); export let c = strStr.map(s => s.charCodeAt(0)); >c : [number, number] >strStr.map(s => s.charCodeAt(0)) : [number, number] ->strStr.map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>strStr.map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } >strStr : [string, string] ->map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } ->s => s.charCodeAt(0) : (this: undefined, s: string) => number +>map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>s => s.charCodeAt(0) : (this: void, s: string) => number >s : string >s.charCodeAt(0) : number >s.charCodeAt : (index: number) => number @@ -83,10 +83,10 @@ export let c = strStr.map(s => s.charCodeAt(0)); export let d = numStr.map(x => x); >d : [string | number, string | number] >numStr.map(x => x) : [string | number, string | number] ->numStr.map : { (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U]; (this: [string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U]; (this: [string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U]; (this: [string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): U[]; (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): U[]; } +>numStr.map : { (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U]; (this: [string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U]; (this: [string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U]; (this: [string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): U[]; (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): U[]; } >numStr : [number, string] ->map : { (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U]; (this: [string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U]; (this: [string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U]; (this: [string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): U[]; (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): U[]; } ->x => x : (this: undefined, x: string | number) => string | number +>map : { (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U]; (this: [string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U]; (this: [string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U]; (this: [string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): U[]; (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): U[]; } +>x => x : (this: void, x: string | number) => string | number >x : string | number >x : string | number @@ -102,10 +102,10 @@ let numNumNum: [number, number, number] = [1, 2, 3]; export let e = numNumNum.map(n => n * n); >e : [number, number, number] >numNumNum.map(n => n * n) : [number, number, number] ->numNumNum.map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>numNumNum.map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >numNumNum : [number, number, number] ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } ->n => n * n : (this: undefined, n: number) => number +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>n => n * n : (this: void, n: number) => number >n : number >n * n : number >n : number @@ -124,10 +124,10 @@ let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4]; export let f = numNumNumNum.map(n => n * n); >f : [number, number, number, number] >numNumNumNum.map(n => n * n) : [number, number, number, number] ->numNumNumNum.map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>numNumNumNum.map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >numNumNumNum : [number, number, number, number] ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } ->n => n * n : (this: undefined, n: number) => number +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>n => n * n : (this: void, n: number) => number >n : number >n * n : number >n : number @@ -147,10 +147,10 @@ let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5]; export let g = numNumNumNumNum.map(n => n * n); >g : [number, number, number, number, number] >numNumNumNumNum.map(n => n * n) : [number, number, number, number, number] ->numNumNumNumNum.map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>numNumNumNumNum.map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >numNumNumNumNum : [number, number, number, number, number] ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } ->n => n * n : (this: undefined, n: number) => number +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>n => n * n : (this: void, n: number) => number >n : number >n * n : number >n : number @@ -172,10 +172,10 @@ let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2 export let h = numNumNumNumNum.map(n => n * n); >h : [number, number, number, number, number] >numNumNumNumNum.map(n => n * n) : [number, number, number, number, number] ->numNumNumNumNum.map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>numNumNumNumNum.map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >numNumNumNumNum : [number, number, number, number, number] ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } ->n => n * n : (this: undefined, n: number) => number +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>n => n * n : (this: void, n: number) => number >n : number >n * n : number >n : number diff --git a/tests/baselines/reference/mapOnTupleTypes02.types b/tests/baselines/reference/mapOnTupleTypes02.types index 1a354dce354..72fbbf31b11 100644 --- a/tests/baselines/reference/mapOnTupleTypes02.types +++ b/tests/baselines/reference/mapOnTupleTypes02.types @@ -9,10 +9,10 @@ export function increment(point: Point) { return point.map(d => d + 1); >point.map(d => d + 1) : [number, number] ->point.map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>point.map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >point : [number, number] ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } ->d => d + 1 : (this: undefined, d: number) => number +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>d => d + 1 : (this: void, d: number) => number >d : number >d + 1 : number >d : number diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types index 7012b25ccbd..716e84dadd0 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types @@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) { return Array.from(arguments); >Array.from(arguments) : any[] ->Array.from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>Array.from : { (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >Array : ArrayConstructor ->from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>from : { (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >arguments : IArguments } diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types index 781e33e850a..d6c384b4280 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types @@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) { return Array.from(arguments); >Array.from(arguments) : any[] ->Array.from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>Array.from : { (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >Array : ArrayConstructor ->from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>from : { (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >arguments : IArguments } diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types index 54c6958dccc..fe6cf35e596 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types @@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) { return Array.from(arguments); >Array.from(arguments) : any[] ->Array.from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>Array.from : { (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >Array : ArrayConstructor ->from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>from : { (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >arguments : IArguments } diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types index 9dd896bc9e6..440ca430a31 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types +++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types @@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) { return Array.from(arguments); >Array.from(arguments) : any[] ->Array.from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>Array.from : { (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >Array : ArrayConstructor ->from : { (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>from : { (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U): U[]; (iterable: Iterable, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (iterable: Iterable, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >arguments : IArguments } diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types index c5368e33a3c..3c3905c501f 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types @@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) { return Array.from(arguments); >Array.from(arguments) : any[] ->Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >Array : ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >arguments : IArguments } diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types index 95144f1fd7a..3d4ba12fa63 100644 --- a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types @@ -7,9 +7,9 @@ function f(x: number, y: number, z: number) { return Array.from(arguments); >Array.from(arguments) : any[] ->Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >Array : ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U): U[]; (arrayLike: ArrayLike, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; (arrayLike: ArrayLike, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; (arrayLike: ArrayLike): T[]; } >arguments : IArguments } diff --git a/tests/baselines/reference/nestedSelf.types b/tests/baselines/reference/nestedSelf.types index 176e0dc28d3..819a76dc380 100644 --- a/tests/baselines/reference/nestedSelf.types +++ b/tests/baselines/reference/nestedSelf.types @@ -12,13 +12,13 @@ module M { public foo() { [1,2,3].map((x) => { return this.n * x; })} >foo : () => void >[1,2,3].map((x) => { return this.n * x; }) : number[] ->[1,2,3].map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>[1,2,3].map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >[1,2,3] : number[] >1 : 1 >2 : 2 >3 : 3 ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } ->(x) => { return this.n * x; } : (this: undefined, x: number) => number +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>(x) => { return this.n * x; } : (this: void, x: number) => number >x : number >this.n * x : number >this.n : number diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types index 700a88a1dab..cee8cc24e44 100644 --- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types +++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types @@ -7,10 +7,10 @@ var regexMatchList = ['', '']; regexMatchList.forEach(match => ''.replace(match, '')); >regexMatchList.forEach(match => ''.replace(match, '')) : void ->regexMatchList.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>regexMatchList.forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } >regexMatchList : string[] ->forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } ->match => ''.replace(match, '') : (this: undefined, match: string) => string +>forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>match => ''.replace(match, '') : (this: void, match: string) => string >match : string >''.replace(match, '') : string >''.replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; } diff --git a/tests/baselines/reference/objectRestForOf.types b/tests/baselines/reference/objectRestForOf.types index b7d1d1ac7be..ba6febd69c2 100644 --- a/tests/baselines/reference/objectRestForOf.types +++ b/tests/baselines/reference/objectRestForOf.types @@ -36,10 +36,10 @@ for ({ x: xx, ...rrestOff } of array ) { for (const norest of array.map(a => ({ ...a, x: 'a string' }))) { >norest : { x: string; y: string; } >array.map(a => ({ ...a, x: 'a string' })) : { x: string; y: string; }[] ->array.map : { (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): U[]; (callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): U[]; } +>array.map : { (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): U[]; (callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): U[]; } >array : { x: number; y: string; }[] ->map : { (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): U[]; (callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): U[]; } ->a => ({ ...a, x: 'a string' }) : (this: undefined, a: { x: number; y: string; }) => { x: string; y: string; } +>map : { (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U]; (this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): U[]; (callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): U[]; } +>a => ({ ...a, x: 'a string' }) : (this: void, a: { x: number; y: string; }) => { x: string; y: string; } >a : { x: number; y: string; } >({ ...a, x: 'a string' }) : { x: string; y: string; } >{ ...a, x: 'a string' } : { x: string; y: string; } diff --git a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types index ad683ef2e15..fa6f2b27fbe 100644 --- a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types +++ b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types @@ -1,15 +1,15 @@ === tests/cases/compiler/simpleArrowFunctionParameterReferencedInObjectLiteral1.ts === [].map(() => [].map(p => ({ X: p }))); >[].map(() => [].map(p => ({ X: p }))) : { X: any; }[][] ->[].map : { (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } +>[].map : { (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } >[] : undefined[] ->map : { (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } +>map : { (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } >() => [].map(p => ({ X: p })) : () => { X: any; }[] >[].map(p => ({ X: p })) : { X: any; }[] ->[].map : { (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } +>[].map : { (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } >[] : undefined[] ->map : { (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } ->p => ({ X: p }) : (this: undefined, p: any) => { X: any; } +>map : { (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; (this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; (this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; (this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; (this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; (this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; (callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; } +>p => ({ X: p }) : (this: void, p: any) => { X: any; } >p : any >({ X: p }) : { X: any; } >{ X: p } : { X: any; } diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types index 01bdfc4bda6..b7dea45c6eb 100644 --- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types +++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types @@ -25,9 +25,9 @@ function foo() { series2.map(seriesExtent); >series2.map(seriesExtent) : any[] ->series2.map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>series2.map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >series2 : number[] ->map : { (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } +>map : { (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; } >seriesExtent : (series: any) => any return null; @@ -38,12 +38,12 @@ function foo() { var keyExtent2: any[] = series.data.map(function (d: string) { return d; }); >keyExtent2 : any[] >series.data.map(function (d: string) { return d; }) : string[] ->series.data.map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>series.data.map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } >series.data : string[] >series : Series >data : string[] ->map : { (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } ->function (d: string) { return d; } : (this: undefined, d: string) => string +>map : { (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; } +>function (d: string) { return d; } : (this: void, d: string) => string >d : string >d : string diff --git a/tests/baselines/reference/targetTypeArgs.types b/tests/baselines/reference/targetTypeArgs.types index e1bcb00ba15..ae09b5185a9 100644 --- a/tests/baselines/reference/targetTypeArgs.types +++ b/tests/baselines/reference/targetTypeArgs.types @@ -19,11 +19,11 @@ foo(function(x) { x }); [1].forEach(function(v,i,a) { v }); >[1].forEach(function(v,i,a) { v }) : void ->[1].forEach : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; } +>[1].forEach : { (callbackfn: (this: void, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: void, value: number, index: number, array: number[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; } >[1] : number[] >1 : 1 ->forEach : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; } ->function(v,i,a) { v } : (this: undefined, v: number, i: number, a: number[]) => void +>forEach : { (callbackfn: (this: void, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: void, value: number, index: number, array: number[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; } +>function(v,i,a) { v } : (this: void, v: number, i: number, a: number[]) => void >v : number >i : number >a : number[] @@ -31,11 +31,11 @@ foo(function(x) { x }); ["hello"].every(function(v,i,a) {return true;}); >["hello"].every(function(v,i,a) {return true;}) : boolean ->["hello"].every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>["hello"].every : { (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } >["hello"] : string[] >"hello" : "hello" ->every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } ->function(v,i,a) {return true;} : (this: undefined, v: string, i: number, a: string[]) => true +>every : { (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>function(v,i,a) {return true;} : (this: void, v: string, i: number, a: string[]) => true >v : string >i : number >a : string[] @@ -43,11 +43,11 @@ foo(function(x) { x }); [1].every(function(v,i,a) {return true;}); >[1].every(function(v,i,a) {return true;}) : boolean ->[1].every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } +>[1].every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } >[1] : number[] >1 : 1 ->every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } ->function(v,i,a) {return true;} : (this: undefined, v: number, i: number, a: number[]) => true +>every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } +>function(v,i,a) {return true;} : (this: void, v: number, i: number, a: number[]) => true >v : number >i : number >a : number[] @@ -55,11 +55,11 @@ foo(function(x) { x }); [1].every(function(v,i,a) {return true;}); >[1].every(function(v,i,a) {return true;}) : boolean ->[1].every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } +>[1].every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } >[1] : number[] >1 : 1 ->every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } ->function(v,i,a) {return true;} : (this: undefined, v: number, i: number, a: number[]) => true +>every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; } +>function(v,i,a) {return true;} : (this: void, v: number, i: number, a: number[]) => true >v : number >i : number >a : number[] @@ -67,11 +67,11 @@ foo(function(x) { x }); ["s"].every(function(v,i,a) {return true;}); >["s"].every(function(v,i,a) {return true;}) : boolean ->["s"].every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>["s"].every : { (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } >["s"] : string[] >"s" : "s" ->every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } ->function(v,i,a) {return true;} : (this: undefined, v: string, i: number, a: string[]) => true +>every : { (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; (callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; } +>function(v,i,a) {return true;} : (this: void, v: string, i: number, a: string[]) => true >v : string >i : number >a : string[] @@ -79,11 +79,11 @@ foo(function(x) { x }); ["s"].forEach(function(v,i,a) { v }); >["s"].forEach(function(v,i,a) { v }) : void ->["s"].forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>["s"].forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } >["s"] : string[] >"s" : "s" ->forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } ->function(v,i,a) { v } : (this: undefined, v: string, i: number, a: string[]) => void +>forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>function(v,i,a) { v } : (this: void, v: string, i: number, a: string[]) => void >v : string >i : number >a : string[] diff --git a/tests/baselines/reference/targetTypeObjectLiteralToAny.types b/tests/baselines/reference/targetTypeObjectLiteralToAny.types index 1364a5b2a23..b8802638728 100644 --- a/tests/baselines/reference/targetTypeObjectLiteralToAny.types +++ b/tests/baselines/reference/targetTypeObjectLiteralToAny.types @@ -10,10 +10,10 @@ function suggest(){ TypeScriptKeywords.forEach(function(keyword) { >TypeScriptKeywords.forEach(function(keyword) { result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any }) : void ->TypeScriptKeywords.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>TypeScriptKeywords.forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } >TypeScriptKeywords : string[] ->forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } ->function(keyword) { result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any } : (this: undefined, keyword: string) => void +>forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; (callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; } +>function(keyword) { result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any } : (this: void, keyword: string) => void >keyword : string result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any diff --git a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.errors.txt b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.errors.txt new file mode 100644 index 00000000000..817478aa68e --- /dev/null +++ b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.errors.txt @@ -0,0 +1,409 @@ +tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts(17,31): error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'. +tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts(20,31): error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'. +tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts(23,31): error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'. + + +==== tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts (3 errors) ==== + class A { + options: string[]; + + addOptions(options: string[]) { + if (!this.options) { + this.options = []; + } + options.forEach(function (item) { + this.options.push(item); + }, this); + return this; + } + + testUndefined(options: string[]) { + const undefinedArr: Array = [] + options.forEach(function () { + undefinedArr.push(this); + ~~~~ +!!! error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'. + }); // case1 + options.forEach(function () { + undefinedArr.push(this); + ~~~~ +!!! error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'. + }, undefined); // case2 + options.forEach(function () { + undefinedArr.push(this); + ~~~~ +!!! error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'. + }, null); // case3 + + const arrLike = {} as ArrayLike + Array.from(arrLike, function (item) { + return this === undefined ? 2 : 1; + }, undefined) + + const iterLike = [] as Iterable + Array.from(iterLike, function (item) { + return this === undefined ? 2 : 1; + }, undefined) + } + + test(options: string[]) { + const thisObject = { + options: [] as string[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + + const arrLike = {} as ArrayLike + Array.from(arrLike, function (item) { + return this.options[item].length + }, thisObject) + + const iterLike = [] as Iterable + Array.from(iterLike, function (item) { + return this.options[item].length + }, thisObject) + } + + test1(options: string[]) { + const thisObject = { + options: [] as ReadonlyArray + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test2(options: Int8Array[]) { + const thisObject = { + options: [] as Int8Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test3(options: Uint8Array[]) { + const thisObject = { + options: [] as Uint8Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test4(options: Float32Array[]) { + const thisObject = { + options: [] as Float32Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test5(options: Uint8ClampedArray[]) { + const thisObject = { + options: [] as Uint8ClampedArray[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test6(options: Int16Array[]) { + const thisObject = { + options: [] as Int16Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test7(options: Uint16Array[]) { + const thisObject = { + options: [] as Uint16Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test8(options: Uint32Array[]) { + const thisObject = { + options: [] as Uint32Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + + test9(options: Float64Array[]) { + const thisObject = { + options: [] as Float64Array[] + }; + + options.find(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.findIndex(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.forEach(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.map(function (val, index) { + if (val === this.options[index]) + return this.options[index]; + }, thisObject); + + options.some(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.filter(function (val, index) { + return val === this.options[index]; + }, thisObject); + + options.every(function (val, index) { + return val === this.options[index]; + }, thisObject); + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/tsxSpreadChildren.types b/tests/baselines/reference/tsxSpreadChildren.types index dcdd0cd7137..7f4609c30b8 100644 --- a/tests/baselines/reference/tsxSpreadChildren.types +++ b/tests/baselines/reference/tsxSpreadChildren.types @@ -63,10 +63,10 @@ function TodoList({ todos }: TodoListProps) { {...todos.map(todo => )} >todos.map(todo => ) : JSX.Element[] ->todos.map : { (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): U[]; (callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): U[]; } +>todos.map : { (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): U[]; (callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): U[]; } >todos : TodoProp[] ->map : { (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): U[]; (callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): U[]; } ->todo => : (this: undefined, todo: TodoProp) => JSX.Element +>map : { (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U]; (this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U]; (this: [TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): U[]; (callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): U[]; } +>todo => : (this: void, todo: TodoProp) => JSX.Element >todo : TodoProp > : JSX.Element >Todo : (prop: { key: number; todo: string; }) => JSX.Element diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types index 21332704326..518bf14d010 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types +++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types @@ -16,10 +16,10 @@ var nodes: TreeNode[]; nodes.map(n => n.name); >nodes.map(n => n.name) : string[] ->nodes.map : { (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): U[]; (callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): U[]; } +>nodes.map : { (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): U[]; (callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): U[]; } >nodes : TreeNode[] ->map : { (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): U[]; (callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): U[]; } ->n => n.name : (this: undefined, n: TreeNode) => string +>map : { (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U]; (this: [TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): U[]; (callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): U[]; } +>n => n.name : (this: void, n: TreeNode) => string >n : TreeNode >n.name : string >n : TreeNode diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types index 6cb4b81e0ce..45054ed6aa0 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types +++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types @@ -27,10 +27,10 @@ var nodes: TreeNodeMiddleman[]; nodes.map(n => n.name); >nodes.map(n => n.name) : string[] ->nodes.map : { (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): U[]; (callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): U[]; } +>nodes.map : { (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): U[]; (callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): U[]; } >nodes : TreeNodeMiddleman[] ->map : { (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): U[]; (callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): U[]; } ->n => n.name : (this: undefined, n: TreeNodeMiddleman) => string +>map : { (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U]; (this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U]; (callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): U[]; (callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): U[]; (callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): U[]; } +>n => n.name : (this: void, n: TreeNodeMiddleman) => string >n : TreeNodeMiddleman >n.name : string >n : TreeNodeMiddleman diff --git a/tests/baselines/reference/typedArrays.types b/tests/baselines/reference/typedArrays.types index 2446fb1e2d9..259d601d426 100644 --- a/tests/baselines/reference/typedArrays.types +++ b/tests/baselines/reference/typedArrays.types @@ -273,9 +273,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { >typedArrays : any[] >0 : 0 >Int8Array.from(obj) : Int8Array ->Int8Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } +>Int8Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } >Int8Array : Int8ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } >obj : number[] typedArrays[1] = Uint8Array.from(obj); @@ -284,9 +284,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { >typedArrays : any[] >1 : 1 >Uint8Array.from(obj) : Uint8Array ->Uint8Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } +>Uint8Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } >Uint8Array : Uint8ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } >obj : number[] typedArrays[2] = Int16Array.from(obj); @@ -295,9 +295,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { >typedArrays : any[] >2 : 2 >Int16Array.from(obj) : Int16Array ->Int16Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } +>Int16Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } >Int16Array : Int16ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } >obj : number[] typedArrays[3] = Uint16Array.from(obj); @@ -306,9 +306,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { >typedArrays : any[] >3 : 3 >Uint16Array.from(obj) : Uint16Array ->Uint16Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } +>Uint16Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } >Uint16Array : Uint16ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } >obj : number[] typedArrays[4] = Int32Array.from(obj); @@ -317,9 +317,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { >typedArrays : any[] >4 : 4 >Int32Array.from(obj) : Int32Array ->Int32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } +>Int32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } >Int32Array : Int32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } >obj : number[] typedArrays[5] = Uint32Array.from(obj); @@ -328,9 +328,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { >typedArrays : any[] >5 : 5 >Uint32Array.from(obj) : Uint32Array ->Uint32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } +>Uint32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } >Uint32Array : Uint32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } >obj : number[] typedArrays[6] = Float32Array.from(obj); @@ -339,9 +339,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { >typedArrays : any[] >6 : 6 >Float32Array.from(obj) : Float32Array ->Float32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } +>Float32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } >Float32Array : Float32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } >obj : number[] typedArrays[7] = Float64Array.from(obj); @@ -350,9 +350,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { >typedArrays : any[] >7 : 7 >Float64Array.from(obj) : Float64Array ->Float64Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } +>Float64Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } >Float64Array : Float64ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } >obj : number[] typedArrays[8] = Uint8ClampedArray.from(obj); @@ -361,9 +361,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { >typedArrays : any[] >8 : 8 >Uint8ClampedArray.from(obj) : Uint8ClampedArray ->Uint8ClampedArray.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } +>Uint8ClampedArray.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } >Uint8ClampedArray : Uint8ClampedArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } >obj : number[] return typedArrays; @@ -385,9 +385,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >typedArrays : any[] >0 : 0 >Int8Array.from(obj) : Int8Array ->Int8Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } +>Int8Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } >Int8Array : Int8ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } >obj : ArrayLike typedArrays[1] = Uint8Array.from(obj); @@ -396,9 +396,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >typedArrays : any[] >1 : 1 >Uint8Array.from(obj) : Uint8Array ->Uint8Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } +>Uint8Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } >Uint8Array : Uint8ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } >obj : ArrayLike typedArrays[2] = Int16Array.from(obj); @@ -407,9 +407,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >typedArrays : any[] >2 : 2 >Int16Array.from(obj) : Int16Array ->Int16Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } +>Int16Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } >Int16Array : Int16ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } >obj : ArrayLike typedArrays[3] = Uint16Array.from(obj); @@ -418,9 +418,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >typedArrays : any[] >3 : 3 >Uint16Array.from(obj) : Uint16Array ->Uint16Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } +>Uint16Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } >Uint16Array : Uint16ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } >obj : ArrayLike typedArrays[4] = Int32Array.from(obj); @@ -429,9 +429,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >typedArrays : any[] >4 : 4 >Int32Array.from(obj) : Int32Array ->Int32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } +>Int32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } >Int32Array : Int32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } >obj : ArrayLike typedArrays[5] = Uint32Array.from(obj); @@ -440,9 +440,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >typedArrays : any[] >5 : 5 >Uint32Array.from(obj) : Uint32Array ->Uint32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } +>Uint32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } >Uint32Array : Uint32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } >obj : ArrayLike typedArrays[6] = Float32Array.from(obj); @@ -451,9 +451,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >typedArrays : any[] >6 : 6 >Float32Array.from(obj) : Float32Array ->Float32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } +>Float32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } >Float32Array : Float32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } >obj : ArrayLike typedArrays[7] = Float64Array.from(obj); @@ -462,9 +462,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >typedArrays : any[] >7 : 7 >Float64Array.from(obj) : Float64Array ->Float64Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } +>Float64Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } >Float64Array : Float64ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } >obj : ArrayLike typedArrays[8] = Uint8ClampedArray.from(obj); @@ -473,9 +473,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >typedArrays : any[] >8 : 8 >Uint8ClampedArray.from(obj) : Uint8ClampedArray ->Uint8ClampedArray.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } +>Uint8ClampedArray.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } >Uint8ClampedArray : Uint8ClampedArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } >obj : ArrayLike return typedArrays; @@ -757,9 +757,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n >typedArrays : any[] >0 : 0 >Int8Array.from(obj, mapFn) : Int8Array ->Int8Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } +>Int8Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } >Int8Array : Int8ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number @@ -769,9 +769,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n >typedArrays : any[] >1 : 1 >Uint8Array.from(obj, mapFn) : Uint8Array ->Uint8Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } +>Uint8Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } >Uint8Array : Uint8ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number @@ -781,9 +781,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n >typedArrays : any[] >2 : 2 >Int16Array.from(obj, mapFn) : Int16Array ->Int16Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } +>Int16Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } >Int16Array : Int16ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number @@ -793,9 +793,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n >typedArrays : any[] >3 : 3 >Uint16Array.from(obj, mapFn) : Uint16Array ->Uint16Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } +>Uint16Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } >Uint16Array : Uint16ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number @@ -805,9 +805,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n >typedArrays : any[] >4 : 4 >Int32Array.from(obj, mapFn) : Int32Array ->Int32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } +>Int32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } >Int32Array : Int32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number @@ -817,9 +817,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n >typedArrays : any[] >5 : 5 >Uint32Array.from(obj, mapFn) : Uint32Array ->Uint32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } +>Uint32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } >Uint32Array : Uint32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number @@ -829,9 +829,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n >typedArrays : any[] >6 : 6 >Float32Array.from(obj, mapFn) : Float32Array ->Float32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } +>Float32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } >Float32Array : Float32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number @@ -841,9 +841,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n >typedArrays : any[] >7 : 7 >Float64Array.from(obj, mapFn) : Float64Array ->Float64Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } +>Float64Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } >Float64Array : Float64ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number @@ -853,9 +853,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n >typedArrays : any[] >8 : 8 >Uint8ClampedArray.from(obj, mapFn) : Uint8ClampedArray ->Uint8ClampedArray.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } +>Uint8ClampedArray.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } >Uint8ClampedArray : Uint8ClampedArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } >obj : ArrayLike >mapFn : (n: number, v: number) => number @@ -882,9 +882,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v >typedArrays : any[] >0 : 0 >Int8Array.from(obj, mapFn, thisArg) : Int8Array ->Int8Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } +>Int8Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } >Int8Array : Int8ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable): Int8Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number >thisArg : {} @@ -895,9 +895,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v >typedArrays : any[] >1 : 1 >Uint8Array.from(obj, mapFn, thisArg) : Uint8Array ->Uint8Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } +>Uint8Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } >Uint8Array : Uint8ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable): Uint8Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number >thisArg : {} @@ -908,9 +908,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v >typedArrays : any[] >2 : 2 >Int16Array.from(obj, mapFn, thisArg) : Int16Array ->Int16Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } +>Int16Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } >Int16Array : Int16ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable): Int16Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number >thisArg : {} @@ -921,9 +921,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v >typedArrays : any[] >3 : 3 >Uint16Array.from(obj, mapFn, thisArg) : Uint16Array ->Uint16Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } +>Uint16Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } >Uint16Array : Uint16ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable): Uint16Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number >thisArg : {} @@ -934,9 +934,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v >typedArrays : any[] >4 : 4 >Int32Array.from(obj, mapFn, thisArg) : Int32Array ->Int32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } +>Int32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } >Int32Array : Int32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable): Int32Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number >thisArg : {} @@ -947,9 +947,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v >typedArrays : any[] >5 : 5 >Uint32Array.from(obj, mapFn, thisArg) : Uint32Array ->Uint32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } +>Uint32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } >Uint32Array : Uint32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable): Uint32Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number >thisArg : {} @@ -960,9 +960,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v >typedArrays : any[] >6 : 6 >Float32Array.from(obj, mapFn, thisArg) : Float32Array ->Float32Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } +>Float32Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } >Float32Array : Float32ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable): Float32Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number >thisArg : {} @@ -973,9 +973,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v >typedArrays : any[] >7 : 7 >Float64Array.from(obj, mapFn, thisArg) : Float64Array ->Float64Array.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } +>Float64Array.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } >Float64Array : Float64ArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable): Float64Array; } >obj : ArrayLike >mapFn : (n: number, v: number) => number >thisArg : {} @@ -986,9 +986,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v >typedArrays : any[] >8 : 8 >Uint8ClampedArray.from(obj, mapFn, thisArg) : Uint8ClampedArray ->Uint8ClampedArray.from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } +>Uint8ClampedArray.from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } >Uint8ClampedArray : Uint8ClampedArrayConstructor ->from : { (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } +>from : { (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: ArrayLike, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; (arrayLike: Iterable, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable): Uint8ClampedArray; } >obj : ArrayLike >mapFn : (n: number, v: number) => number >thisArg : {} From 92eaf5dc9b97d80645d636f8243bc1455e10de5a Mon Sep 17 00:00:00 2001 From: Ryan Cavanaugh Date: Thu, 13 Apr 2017 16:39:07 -0700 Subject: [PATCH 31/35] Lint --- src/harness/unittests/cachingInServerLSHost.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/harness/unittests/cachingInServerLSHost.ts b/src/harness/unittests/cachingInServerLSHost.ts index 5ce93fa8231..0725bf36a3b 100644 --- a/src/harness/unittests/cachingInServerLSHost.ts +++ b/src/harness/unittests/cachingInServerLSHost.ts @@ -72,7 +72,7 @@ namespace ts { typingsInstaller: undefined }; const projectService = new server.ProjectService(svcOpts); - const rootScriptInfo = projectService.getOrCreateScriptInfo(rootFile, /* openedByClient */true, /*containingProject*/ undefined); + const rootScriptInfo = projectService.getOrCreateScriptInfo(rootFile, /* openedByClient */ true, /*containingProject*/ undefined); const project = projectService.createInferredProjectWithRootFileIfNecessary(rootScriptInfo); project.setCompilerOptions({ module: ts.ModuleKind.AMD } ); From e9fd2bcf0f4404716daae6b11816b91de6253c63 Mon Sep 17 00:00:00 2001 From: Herrington Darkholme Date: Fri, 14 Apr 2017 10:36:49 +0800 Subject: [PATCH 32/35] address code review feedback --- src/compiler/checker.ts | 11 +++++++++-- src/compiler/diagnosticMessages.json | 6 +++++- .../InvalidNonInstantiatedModule.errors.txt | 8 ++++---- .../aliasOnMergedModuleInterface.errors.txt | 4 ++-- .../reference/assignToModule.errors.txt | 4 ++-- .../assignmentToReferenceTypes.errors.txt | 4 ++-- .../reference/assignments.errors.txt | 4 ++-- ...efaultArgsInFunctionExpressions.errors.txt | 4 ++-- ...peReferenceWithoutTypeArgument2.errors.txt | 4 ++-- .../importDeclWithClassModifiers.errors.txt | 12 ++++++------ .../importDeclWithDeclareModifier.errors.txt | 4 ++-- .../importDeclWithExportModifier.errors.txt | 4 ++-- ...portModifierAndExportAssignment.errors.txt | 4 ++-- .../importStatementsInterfaces.errors.txt | 4 ++-- .../interfaceNameAsIdentifier.errors.txt | 4 ++-- .../reference/memberScope.errors.txt | 4 ++-- .../reference/moduleAsBaseType.errors.txt | 12 ++++++------ .../moduleWithNoValuesAsType.errors.txt | 12 ++++++------ .../reference/namespaceModule.errors.txt | 19 ------------------- tests/baselines/reference/namespaceModule.js | 15 --------------- .../typeUsedAsValueError2.errors.txt | 4 ++-- .../typeofInternalModules.errors.txt | 8 ++++---- tests/cases/compiler/namespaceModule.ts | 9 --------- 23 files changed, 66 insertions(+), 98 deletions(-) delete mode 100644 tests/baselines/reference/namespaceModule.errors.txt delete mode 100644 tests/baselines/reference/namespaceModule.js delete mode 100644 tests/cases/compiler/namespaceModule.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 920bbceb6cf..b8fc42eee08 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1202,10 +1202,17 @@ namespace ts { } function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation: Node, name: string, meaning: SymbolFlags): boolean { - if (meaning & (SymbolFlags.Value & ~SymbolFlags.NamespaceModule)) { + if (meaning & (SymbolFlags.Value & ~SymbolFlags.NamespaceModule & ~SymbolFlags.Type)) { const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.NamespaceModule & ~SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined)); if (symbol) { - error(errorLocation, Diagnostics.Cannot_use_namespace_0_as_a_value_here_because_it_has_no_value_export, name); + error(errorLocation, Diagnostics.Cannot_use_namespace_0_as_a_value, name); + return true; + } + } + else if (meaning & (SymbolFlags.Type & ~SymbolFlags.NamespaceModule & ~SymbolFlags.Value)) { + const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.NamespaceModule & ~SymbolFlags.Type, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined)); + if (symbol) { + error(errorLocation, Diagnostics.Cannot_use_namespace_0_as_a_type, name); return true; } } diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 4e70cf65849..10dc25ef70e 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -2099,10 +2099,14 @@ "category": "Error", "code": 2707 }, - "Cannot use namespace '{0}' as a value here because it has no value export.": { + "Cannot use namespace '{0}' as a value.": { "category": "Error", "code": 2708 }, + "Cannot use namespace '{0}' as a type.": { + "category": "Error", + "code": 2709 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", diff --git a/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt b/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt index bcfb27652c9..bc8582debd9 100644 --- a/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt +++ b/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt @@ -1,5 +1,5 @@ -tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(5,9): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. -tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(7,15): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(5,9): error TS2708: Cannot use namespace 'M' as a value. +tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(7,15): error TS2708: Cannot use namespace 'M' as a value. ==== tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts (2 errors) ==== @@ -9,9 +9,9 @@ tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiate var m = M; // Error, not instantiated can not be used as var ~ -!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'M' as a value. var x: typeof M; // Error only a namespace ~ -!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'M' as a value. \ No newline at end of file diff --git a/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt b/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt index ae56be397fe..66d9eebb3dd 100644 --- a/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt +++ b/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/aliasOnMergedModuleInterface_1.ts(5,16): error TS2708: Cannot use namespace 'foo' as a value here because it has no value export. +tests/cases/compiler/aliasOnMergedModuleInterface_1.ts(5,16): error TS2708: Cannot use namespace 'foo' as a value. ==== tests/cases/compiler/aliasOnMergedModuleInterface_1.ts (1 errors) ==== @@ -8,7 +8,7 @@ tests/cases/compiler/aliasOnMergedModuleInterface_1.ts(5,16): error TS2708: Cann z.bar("hello"); // This should be ok var x: foo.A = foo.bar("hello"); // foo.A should be ok but foo.bar should be error ~~~ -!!! error TS2708: Cannot use namespace 'foo' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'foo' as a value. ==== tests/cases/compiler/aliasOnMergedModuleInterface_0.ts (0 errors) ==== declare module "foo" diff --git a/tests/baselines/reference/assignToModule.errors.txt b/tests/baselines/reference/assignToModule.errors.txt index f7abfa90bf7..0b8b6f27deb 100644 --- a/tests/baselines/reference/assignToModule.errors.txt +++ b/tests/baselines/reference/assignToModule.errors.txt @@ -1,8 +1,8 @@ -tests/cases/compiler/assignToModule.ts(2,1): error TS2708: Cannot use namespace 'A' as a value here because it has no value export. +tests/cases/compiler/assignToModule.ts(2,1): error TS2708: Cannot use namespace 'A' as a value. ==== tests/cases/compiler/assignToModule.ts (1 errors) ==== module A {} A = undefined; // invalid LHS ~ -!!! error TS2708: Cannot use namespace 'A' as a value here because it has no value export. \ No newline at end of file +!!! error TS2708: Cannot use namespace 'A' as a value. \ No newline at end of file diff --git a/tests/baselines/reference/assignmentToReferenceTypes.errors.txt b/tests/baselines/reference/assignmentToReferenceTypes.errors.txt index 8c937e02766..5e42a2e79c6 100644 --- a/tests/baselines/reference/assignmentToReferenceTypes.errors.txt +++ b/tests/baselines/reference/assignmentToReferenceTypes.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/assignmentToReferenceTypes.ts(5,1): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +tests/cases/compiler/assignmentToReferenceTypes.ts(5,1): error TS2708: Cannot use namespace 'M' as a value. tests/cases/compiler/assignmentToReferenceTypes.ts(9,1): error TS2539: Cannot assign to 'C' because it is not a variable. tests/cases/compiler/assignmentToReferenceTypes.ts(13,1): error TS2539: Cannot assign to 'E' because it is not a variable. tests/cases/compiler/assignmentToReferenceTypes.ts(16,1): error TS2539: Cannot assign to 'f' because it is not a variable. @@ -11,7 +11,7 @@ tests/cases/compiler/assignmentToReferenceTypes.ts(16,1): error TS2539: Cannot a } M = null; ~ -!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'M' as a value. class C { } diff --git a/tests/baselines/reference/assignments.errors.txt b/tests/baselines/reference/assignments.errors.txt index 2c3fff0be59..cb8b7a17bdf 100644 --- a/tests/baselines/reference/assignments.errors.txt +++ b/tests/baselines/reference/assignments.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(11,1): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(11,1): error TS2708: Cannot use namespace 'M' as a value. tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(14,1): error TS2539: Cannot assign to 'C' because it is not a variable. tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(17,1): error TS2539: Cannot assign to 'E' because it is not a variable. tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(18,3): error TS2540: Cannot assign to 'A' because it is a constant or a read-only property. @@ -19,7 +19,7 @@ tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(31,1): er module M { } M = null; // Error ~ -!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'M' as a value. class C { } C = null; // Error diff --git a/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt b/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt index 889a6c3ce79..d46963caeed 100644 --- a/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt +++ b/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt @@ -5,7 +5,7 @@ tests/cases/compiler/defaultArgsInFunctionExpressions.ts(11,1): error TS2322: Ty tests/cases/compiler/defaultArgsInFunctionExpressions.ts(14,51): error TS2352: Type 'string' cannot be converted to type 'number'. tests/cases/compiler/defaultArgsInFunctionExpressions.ts(17,41): error TS2322: Type '""' is not assignable to type 'number'. tests/cases/compiler/defaultArgsInFunctionExpressions.ts(20,62): error TS2352: Type 'string' cannot be converted to type 'number'. -tests/cases/compiler/defaultArgsInFunctionExpressions.ts(28,15): error TS2708: Cannot use namespace 'T' as a value here because it has no value export. +tests/cases/compiler/defaultArgsInFunctionExpressions.ts(28,15): error TS2708: Cannot use namespace 'T' as a value. ==== tests/cases/compiler/defaultArgsInFunctionExpressions.ts (8 errors) ==== @@ -52,7 +52,7 @@ tests/cases/compiler/defaultArgsInFunctionExpressions.ts(28,15): error TS2708: C var f6 = (t = T) => { }; ~ -!!! error TS2708: Cannot use namespace 'T' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'T' as a value. var f7 = (t = U) => { return t; }; f7().x; \ No newline at end of file diff --git a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt index 05d88ae9d39..276654562a1 100644 --- a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt +++ b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt @@ -15,7 +15,7 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(18,38): error TS2314: Generic type 'I' requires 1 type argument(s). tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(20,17): error TS2689: Cannot extend an interface 'I'. Did you mean 'implements'? tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(23,21): error TS2314: Generic type 'I' requires 1 type argument(s). -tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(29,18): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(29,18): error TS2708: Cannot use namespace 'M' as a value. tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(30,24): error TS2314: Generic type 'E' requires 1 type argument(s). tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(31,24): error TS2694: Namespace 'M' has no exported member 'C'. tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(33,22): error TS2314: Generic type 'I' requires 1 type argument(s). @@ -89,7 +89,7 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc class D2 extends M.C { } ~ -!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'M' as a value. interface D3 { } ~~~ !!! error TS2314: Generic type 'E' requires 1 type argument(s). diff --git a/tests/baselines/reference/importDeclWithClassModifiers.errors.txt b/tests/baselines/reference/importDeclWithClassModifiers.errors.txt index 8c82322d384..1f545bb01f2 100644 --- a/tests/baselines/reference/importDeclWithClassModifiers.errors.txt +++ b/tests/baselines/reference/importDeclWithClassModifiers.errors.txt @@ -1,11 +1,11 @@ tests/cases/compiler/importDeclWithClassModifiers.ts(5,8): error TS1044: 'public' modifier cannot appear on a module or namespace element. -tests/cases/compiler/importDeclWithClassModifiers.ts(5,26): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +tests/cases/compiler/importDeclWithClassModifiers.ts(5,26): error TS2708: Cannot use namespace 'x' as a value. tests/cases/compiler/importDeclWithClassModifiers.ts(5,28): error TS2694: Namespace 'x' has no exported member 'c'. tests/cases/compiler/importDeclWithClassModifiers.ts(6,8): error TS1044: 'private' modifier cannot appear on a module or namespace element. -tests/cases/compiler/importDeclWithClassModifiers.ts(6,27): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +tests/cases/compiler/importDeclWithClassModifiers.ts(6,27): error TS2708: Cannot use namespace 'x' as a value. tests/cases/compiler/importDeclWithClassModifiers.ts(6,29): error TS2694: Namespace 'x' has no exported member 'c'. tests/cases/compiler/importDeclWithClassModifiers.ts(7,8): error TS1044: 'static' modifier cannot appear on a module or namespace element. -tests/cases/compiler/importDeclWithClassModifiers.ts(7,26): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +tests/cases/compiler/importDeclWithClassModifiers.ts(7,26): error TS2708: Cannot use namespace 'x' as a value. tests/cases/compiler/importDeclWithClassModifiers.ts(7,28): error TS2694: Namespace 'x' has no exported member 'c'. @@ -18,21 +18,21 @@ tests/cases/compiler/importDeclWithClassModifiers.ts(7,28): error TS2694: Namesp ~~~~~~ !!! error TS1044: 'public' modifier cannot appear on a module or namespace element. ~ -!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export private import b = x.c; ~~~~~~~ !!! error TS1044: 'private' modifier cannot appear on a module or namespace element. ~ -!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export static import c = x.c; ~~~~~~ !!! error TS1044: 'static' modifier cannot appear on a module or namespace element. ~ -!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. var b: a; diff --git a/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt b/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt index 696926dd4a1..93619813aa2 100644 --- a/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt +++ b/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/importDeclWithDeclareModifier.ts(5,9): error TS1029: 'export' modifier must precede 'declare' modifier. -tests/cases/compiler/importDeclWithDeclareModifier.ts(5,27): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +tests/cases/compiler/importDeclWithDeclareModifier.ts(5,27): error TS2708: Cannot use namespace 'x' as a value. tests/cases/compiler/importDeclWithDeclareModifier.ts(5,29): error TS2694: Namespace 'x' has no exported member 'c'. @@ -12,7 +12,7 @@ tests/cases/compiler/importDeclWithDeclareModifier.ts(5,29): error TS2694: Names ~~~~~~ !!! error TS1029: 'export' modifier must precede 'declare' modifier. ~ -!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. var b: a; diff --git a/tests/baselines/reference/importDeclWithExportModifier.errors.txt b/tests/baselines/reference/importDeclWithExportModifier.errors.txt index d211b750ca3..2a5dbbf74ef 100644 --- a/tests/baselines/reference/importDeclWithExportModifier.errors.txt +++ b/tests/baselines/reference/importDeclWithExportModifier.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/importDeclWithExportModifier.ts(5,19): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +tests/cases/compiler/importDeclWithExportModifier.ts(5,19): error TS2708: Cannot use namespace 'x' as a value. tests/cases/compiler/importDeclWithExportModifier.ts(5,21): error TS2694: Namespace 'x' has no exported member 'c'. @@ -9,7 +9,7 @@ tests/cases/compiler/importDeclWithExportModifier.ts(5,21): error TS2694: Namesp } export import a = x.c; ~ -!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. var b: a; diff --git a/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt b/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt index fbe7fde272d..f9f683c502b 100644 --- a/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt +++ b/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(5,19): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(5,19): error TS2708: Cannot use namespace 'x' as a value. tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(5,21): error TS2694: Namespace 'x' has no exported member 'c'. tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(6,1): error TS2309: An export assignment cannot be used in a module with other exported elements. @@ -10,7 +10,7 @@ tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(6,1): er } export import a = x.c; ~ -!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export = x; diff --git a/tests/baselines/reference/importStatementsInterfaces.errors.txt b/tests/baselines/reference/importStatementsInterfaces.errors.txt index d591997117f..a43c368a2c2 100644 --- a/tests/baselines/reference/importStatementsInterfaces.errors.txt +++ b/tests/baselines/reference/importStatementsInterfaces.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/internalModules/codeGeneration/importStatementsInterfaces.ts(23,19): error TS2708: Cannot use namespace 'a' as a value here because it has no value export. +tests/cases/conformance/internalModules/codeGeneration/importStatementsInterfaces.ts(23,19): error TS2708: Cannot use namespace 'a' as a value. ==== tests/cases/conformance/internalModules/codeGeneration/importStatementsInterfaces.ts (1 errors) ==== @@ -26,7 +26,7 @@ tests/cases/conformance/internalModules/codeGeneration/importStatementsInterface import b = a.inA; var m: typeof a; ~ -!!! error TS2708: Cannot use namespace 'a' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'a' as a value. var p: b.Point3D; var p = {x:0, y:0, z: 0 }; } diff --git a/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt b/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt index faa6a0096fa..cc9cc927d0f 100644 --- a/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt +++ b/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/interfaceNameAsIdentifier.ts(4,1): error TS2693: 'C' only refers to a type, but is being used as a value here. -tests/cases/compiler/interfaceNameAsIdentifier.ts(12,1): error TS2708: Cannot use namespace 'm2' as a value here because it has no value export. +tests/cases/compiler/interfaceNameAsIdentifier.ts(12,1): error TS2708: Cannot use namespace 'm2' as a value. ==== tests/cases/compiler/interfaceNameAsIdentifier.ts (2 errors) ==== @@ -18,5 +18,5 @@ tests/cases/compiler/interfaceNameAsIdentifier.ts(12,1): error TS2708: Cannot us m2.C(); ~~ -!!! error TS2708: Cannot use namespace 'm2' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'm2' as a value. \ No newline at end of file diff --git a/tests/baselines/reference/memberScope.errors.txt b/tests/baselines/reference/memberScope.errors.txt index 1d69c350d7c..7af426828db 100644 --- a/tests/baselines/reference/memberScope.errors.txt +++ b/tests/baselines/reference/memberScope.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/memberScope.ts(4,11): error TS2708: Cannot use namespace 'Basil' as a value here because it has no value export. +tests/cases/compiler/memberScope.ts(4,11): error TS2708: Cannot use namespace 'Basil' as a value. ==== tests/cases/compiler/memberScope.ts (1 errors) ==== @@ -7,7 +7,7 @@ tests/cases/compiler/memberScope.ts(4,11): error TS2708: Cannot use namespace 'B export module Basil { } var z = Basil.Pepper; ~~~~~ -!!! error TS2708: Cannot use namespace 'Basil' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'Basil' as a value. } \ No newline at end of file diff --git a/tests/baselines/reference/moduleAsBaseType.errors.txt b/tests/baselines/reference/moduleAsBaseType.errors.txt index 5313c28fbae..fd5b4f581f9 100644 --- a/tests/baselines/reference/moduleAsBaseType.errors.txt +++ b/tests/baselines/reference/moduleAsBaseType.errors.txt @@ -1,16 +1,16 @@ -tests/cases/compiler/moduleAsBaseType.ts(2,17): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. -tests/cases/compiler/moduleAsBaseType.ts(3,21): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. -tests/cases/compiler/moduleAsBaseType.ts(4,21): error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +tests/cases/compiler/moduleAsBaseType.ts(2,17): error TS2708: Cannot use namespace 'M' as a value. +tests/cases/compiler/moduleAsBaseType.ts(3,21): error TS2709: Cannot use namespace 'M' as a type. +tests/cases/compiler/moduleAsBaseType.ts(4,21): error TS2709: Cannot use namespace 'M' as a type. ==== tests/cases/compiler/moduleAsBaseType.ts (3 errors) ==== module M {} class C extends M {} ~ -!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'M' as a value. interface I extends M { } ~ -!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. +!!! error TS2709: Cannot use namespace 'M' as a type. class C2 implements M { } ~ -!!! error TS2708: Cannot use namespace 'M' as a value here because it has no value export. \ No newline at end of file +!!! error TS2709: Cannot use namespace 'M' as a type. \ No newline at end of file diff --git a/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt b/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt index 5636b97e8cd..21abac79217 100644 --- a/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt +++ b/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt @@ -1,20 +1,20 @@ -tests/cases/compiler/moduleWithNoValuesAsType.ts(2,8): error TS2708: Cannot use namespace 'A' as a value here because it has no value export. -tests/cases/compiler/moduleWithNoValuesAsType.ts(7,8): error TS2708: Cannot use namespace 'B' as a value here because it has no value export. -tests/cases/compiler/moduleWithNoValuesAsType.ts(15,8): error TS2708: Cannot use namespace 'C' as a value here because it has no value export. +tests/cases/compiler/moduleWithNoValuesAsType.ts(2,8): error TS2709: Cannot use namespace 'A' as a type. +tests/cases/compiler/moduleWithNoValuesAsType.ts(7,8): error TS2709: Cannot use namespace 'B' as a type. +tests/cases/compiler/moduleWithNoValuesAsType.ts(15,8): error TS2709: Cannot use namespace 'C' as a type. ==== tests/cases/compiler/moduleWithNoValuesAsType.ts (3 errors) ==== module A { } var a: A; // error ~ -!!! error TS2708: Cannot use namespace 'A' as a value here because it has no value export. +!!! error TS2709: Cannot use namespace 'A' as a type. module B { interface I {} } var b: B; // error ~ -!!! error TS2708: Cannot use namespace 'B' as a value here because it has no value export. +!!! error TS2709: Cannot use namespace 'B' as a type. module C { module M { @@ -24,4 +24,4 @@ tests/cases/compiler/moduleWithNoValuesAsType.ts(15,8): error TS2708: Cannot use var c: C; // error ~ -!!! error TS2708: Cannot use namespace 'C' as a value here because it has no value export. \ No newline at end of file +!!! error TS2709: Cannot use namespace 'C' as a type. \ No newline at end of file diff --git a/tests/baselines/reference/namespaceModule.errors.txt b/tests/baselines/reference/namespaceModule.errors.txt deleted file mode 100644 index b23f9621c58..00000000000 --- a/tests/baselines/reference/namespaceModule.errors.txt +++ /dev/null @@ -1,19 +0,0 @@ -tests/cases/compiler/namespaceModule.ts(3,1): error TS2708: Cannot use namespace 'z' as a value here because it has no value export. -tests/cases/compiler/namespaceModule.ts(9,1): error TS2708: Cannot use namespace 'x' as a value here because it has no value export. - - -==== tests/cases/compiler/namespaceModule.ts (2 errors) ==== - namespace z {} - - z; - ~ -!!! error TS2708: Cannot use namespace 'z' as a value here because it has no value export. - - namespace x { - export type z = string; - } - - x; - ~ -!!! error TS2708: Cannot use namespace 'x' as a value here because it has no value export. - \ No newline at end of file diff --git a/tests/baselines/reference/namespaceModule.js b/tests/baselines/reference/namespaceModule.js deleted file mode 100644 index 18bf3cf7b22..00000000000 --- a/tests/baselines/reference/namespaceModule.js +++ /dev/null @@ -1,15 +0,0 @@ -//// [namespaceModule.ts] -namespace z {} - -z; - -namespace x { - export type z = string; -} - -x; - - -//// [namespaceModule.js] -z; -x; diff --git a/tests/baselines/reference/typeUsedAsValueError2.errors.txt b/tests/baselines/reference/typeUsedAsValueError2.errors.txt index a471055913d..4aac95faa25 100644 --- a/tests/baselines/reference/typeUsedAsValueError2.errors.txt +++ b/tests/baselines/reference/typeUsedAsValueError2.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/world.ts(4,1): error TS2693: 'HelloInterface' only refers to a type, but is being used as a value here. -tests/cases/compiler/world.ts(5,1): error TS2708: Cannot use namespace 'HelloNamespace' as a value here because it has no value export. +tests/cases/compiler/world.ts(5,1): error TS2708: Cannot use namespace 'HelloNamespace' as a value. ==== tests/cases/compiler/world.ts (2 errors) ==== @@ -11,7 +11,7 @@ tests/cases/compiler/world.ts(5,1): error TS2708: Cannot use namespace 'HelloNam !!! error TS2693: 'HelloInterface' only refers to a type, but is being used as a value here. HelloNamespace.world; ~~~~~~~~~~~~~~ -!!! error TS2708: Cannot use namespace 'HelloNamespace' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'HelloNamespace' as a value. ==== tests/cases/compiler/helloInterface.ts (0 errors) ==== interface HelloInterface { world: any; diff --git a/tests/baselines/reference/typeofInternalModules.errors.txt b/tests/baselines/reference/typeofInternalModules.errors.txt index b84e65fe218..5402249ea63 100644 --- a/tests/baselines/reference/typeofInternalModules.errors.txt +++ b/tests/baselines/reference/typeofInternalModules.errors.txt @@ -1,8 +1,8 @@ -tests/cases/compiler/typeofInternalModules.ts(15,16): error TS2708: Cannot use namespace 'importUninst' as a value here because it has no value export. +tests/cases/compiler/typeofInternalModules.ts(15,16): error TS2708: Cannot use namespace 'importUninst' as a value. tests/cases/compiler/typeofInternalModules.ts(17,9): error TS2304: Cannot find name 'Outer'. tests/cases/compiler/typeofInternalModules.ts(19,1): error TS2322: Type 'typeof Outer' is not assignable to type 'typeof instantiated'. Property 'C' is missing in type 'typeof Outer'. -tests/cases/compiler/typeofInternalModules.ts(21,16): error TS2708: Cannot use namespace 'importUninst' as a value here because it has no value export. +tests/cases/compiler/typeofInternalModules.ts(21,16): error TS2708: Cannot use namespace 'importUninst' as a value. tests/cases/compiler/typeofInternalModules.ts(23,1): error TS2322: Type 'typeof instantiated' is not assignable to type 'typeof Outer'. Property 'instantiated' is missing in type 'typeof instantiated'. @@ -24,7 +24,7 @@ tests/cases/compiler/typeofInternalModules.ts(23,1): error TS2322: Type 'typeof var x2: importInst.C = new x1(); var x3: typeof importUninst.P; // Error again ~~~~~~~~~~~~ -!!! error TS2708: Cannot use namespace 'importUninst' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'importUninst' as a value. var x4: Outer = Outer; ~~~~~ @@ -37,7 +37,7 @@ tests/cases/compiler/typeofInternalModules.ts(23,1): error TS2322: Type 'typeof x5 = Outer.instantiated; var x6: typeof importUninst; ~~~~~~~~~~~~ -!!! error TS2708: Cannot use namespace 'importUninst' as a value here because it has no value export. +!!! error TS2708: Cannot use namespace 'importUninst' as a value. var x7: typeof Outer = Outer; x7 = importInst; ~~ diff --git a/tests/cases/compiler/namespaceModule.ts b/tests/cases/compiler/namespaceModule.ts deleted file mode 100644 index a1ad71d96a0..00000000000 --- a/tests/cases/compiler/namespaceModule.ts +++ /dev/null @@ -1,9 +0,0 @@ -namespace z {} - -z; - -namespace x { - export type z = string; -} - -x; From 959187607dc5c012943132478ed2b402e2337685 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Fri, 14 Apr 2017 09:28:31 -0700 Subject: [PATCH 33/35] serializeTypeNode handles `object` This was just overlooked earlier. --- src/compiler/transformers/ts.ts | 3 ++ .../reference/emitDecoratorMetadata_object.js | 38 +++++++++++++++++++ .../emitDecoratorMetadata_object.symbols | 26 +++++++++++++ .../emitDecoratorMetadata_object.types | 26 +++++++++++++ .../compiler/emitDecoratorMetadata_object.ts | 13 +++++++ 5 files changed, 106 insertions(+) create mode 100644 tests/baselines/reference/emitDecoratorMetadata_object.js create mode 100644 tests/baselines/reference/emitDecoratorMetadata_object.symbols create mode 100644 tests/baselines/reference/emitDecoratorMetadata_object.types create mode 100644 tests/cases/compiler/emitDecoratorMetadata_object.ts diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 0daf76fa9ec..18387d82611 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -1707,6 +1707,9 @@ namespace ts { case SyntaxKind.StringKeyword: return createIdentifier("String"); + case SyntaxKind.ObjectKeyword: + return createIdentifier("Object"); + case SyntaxKind.LiteralType: switch ((node).literal.kind) { case SyntaxKind.StringLiteral: diff --git a/tests/baselines/reference/emitDecoratorMetadata_object.js b/tests/baselines/reference/emitDecoratorMetadata_object.js new file mode 100644 index 00000000000..a8c8c360dfc --- /dev/null +++ b/tests/baselines/reference/emitDecoratorMetadata_object.js @@ -0,0 +1,38 @@ +//// [emitDecoratorMetadata_object.ts] +declare const MyClassDecorator: ClassDecorator; +declare const MyMethodDecorator: MethodDecorator; + +@MyClassDecorator +class A { + constructor(hi: object) {} + @MyMethodDecorator + method(there: object) {} +} + + +//// [emitDecoratorMetadata_object.js] +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +var A = (function () { + function A(hi) { + } + A.prototype.method = function (there) { }; + return A; +}()); +__decorate([ + MyMethodDecorator, + __metadata("design:type", Function), + __metadata("design:paramtypes", [Object]), + __metadata("design:returntype", void 0) +], A.prototype, "method", null); +A = __decorate([ + MyClassDecorator, + __metadata("design:paramtypes", [Object]) +], A); diff --git a/tests/baselines/reference/emitDecoratorMetadata_object.symbols b/tests/baselines/reference/emitDecoratorMetadata_object.symbols new file mode 100644 index 00000000000..21cd801fcdd --- /dev/null +++ b/tests/baselines/reference/emitDecoratorMetadata_object.symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/emitDecoratorMetadata_object.ts === +declare const MyClassDecorator: ClassDecorator; +>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_object.ts, 0, 13)) +>ClassDecorator : Symbol(ClassDecorator, Decl(lib.d.ts, --, --)) + +declare const MyMethodDecorator: MethodDecorator; +>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_object.ts, 1, 13)) +>MethodDecorator : Symbol(MethodDecorator, Decl(lib.d.ts, --, --)) + +@MyClassDecorator +>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_object.ts, 0, 13)) + +class A { +>A : Symbol(A, Decl(emitDecoratorMetadata_object.ts, 1, 49)) + + constructor(hi: object) {} +>hi : Symbol(hi, Decl(emitDecoratorMetadata_object.ts, 5, 16)) + + @MyMethodDecorator +>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_object.ts, 1, 13)) + + method(there: object) {} +>method : Symbol(A.method, Decl(emitDecoratorMetadata_object.ts, 5, 30)) +>there : Symbol(there, Decl(emitDecoratorMetadata_object.ts, 7, 11)) +} + diff --git a/tests/baselines/reference/emitDecoratorMetadata_object.types b/tests/baselines/reference/emitDecoratorMetadata_object.types new file mode 100644 index 00000000000..a5d5b2a242a --- /dev/null +++ b/tests/baselines/reference/emitDecoratorMetadata_object.types @@ -0,0 +1,26 @@ +=== tests/cases/compiler/emitDecoratorMetadata_object.ts === +declare const MyClassDecorator: ClassDecorator; +>MyClassDecorator : ClassDecorator +>ClassDecorator : ClassDecorator + +declare const MyMethodDecorator: MethodDecorator; +>MyMethodDecorator : MethodDecorator +>MethodDecorator : MethodDecorator + +@MyClassDecorator +>MyClassDecorator : ClassDecorator + +class A { +>A : A + + constructor(hi: object) {} +>hi : object + + @MyMethodDecorator +>MyMethodDecorator : MethodDecorator + + method(there: object) {} +>method : (there: object) => void +>there : object +} + diff --git a/tests/cases/compiler/emitDecoratorMetadata_object.ts b/tests/cases/compiler/emitDecoratorMetadata_object.ts new file mode 100644 index 00000000000..d1bdc0c7c6b --- /dev/null +++ b/tests/cases/compiler/emitDecoratorMetadata_object.ts @@ -0,0 +1,13 @@ +// @experimentaldecorators: true +// @emitdecoratormetadata: true +// @target: ES5 + +declare const MyClassDecorator: ClassDecorator; +declare const MyMethodDecorator: MethodDecorator; + +@MyClassDecorator +class A { + constructor(hi: object) {} + @MyMethodDecorator + method(there: object) {} +} From ccda015578858dce5746bb21d0e9500f5a80908c Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Fri, 14 Apr 2017 09:38:53 -0700 Subject: [PATCH 34/35] Fix failing fourslash test --- tests/cases/fourslash/completionEntryForUnionMethod.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/cases/fourslash/completionEntryForUnionMethod.ts b/tests/cases/fourslash/completionEntryForUnionMethod.ts index 2dc80e757b2..8c112a6d52e 100644 --- a/tests/cases/fourslash/completionEntryForUnionMethod.ts +++ b/tests/cases/fourslash/completionEntryForUnionMethod.ts @@ -5,7 +5,7 @@ goTo.marker(); verify.quickInfoIs( - "(property) map: {\n (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U];\n (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U];\n (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U];\n (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U];\n (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U];\n (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U];\n (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U];\n (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U];\n (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U];\n (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[];\n (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[];\n (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[];\n} | {\n (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U];\n (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U];\n (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U];\n (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U];\n (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U];\n (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U];\n (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U];\n (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U];\n (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U];\n (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[];\n (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[];\n (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[];\n}", + "(property) map: {\n (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U];\n (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U];\n (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U];\n (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U];\n (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U];\n (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U];\n (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U];\n (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U];\n (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U];\n (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[];\n (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[];\n (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[];\n} | {\n (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U];\n (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U];\n (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U];\n (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U];\n (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U];\n (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U];\n (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U];\n (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U];\n (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U];\n (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[];\n (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[];\n (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[];\n}", "Calls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results."); -verify.completionListContains('map', "(property) map: {\n (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U];\n (this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U];\n (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U];\n (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U];\n (this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U];\n (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U];\n (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U];\n (this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U];\n (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U];\n (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[];\n (callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[];\n (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[];\n} | {\n (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U];\n (this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U];\n (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U];\n (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U];\n (this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U];\n (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U];\n (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U];\n (this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U];\n (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U];\n (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[];\n (callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[];\n (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[];\n}"); +verify.completionListContains('map', "(property) map: {\n (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U];\n (this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U];\n (this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U];\n (this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U];\n (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U];\n (this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U];\n (this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U];\n (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U];\n (this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U];\n (this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U];\n (callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[];\n (callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[];\n (callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[];\n} | {\n (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U];\n (this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U];\n (this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U];\n (this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U];\n (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U];\n (this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U];\n (this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U];\n (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U];\n (this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U];\n (this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U];\n (callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[];\n (callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[];\n (callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[];\n}"); From c83a3d07decacb45bbec2c6520dc00c51ce923c4 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Fri, 14 Apr 2017 10:21:51 -0700 Subject: [PATCH 35/35] Accept baseline --- ...gClassStaticMembersFromAssignments.symbols | 57 +++++++++---------- ...ingClassStaticMembersFromAssignments.types | 1 - 2 files changed, 28 insertions(+), 30 deletions(-) diff --git a/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols index 85f8e2a83e6..2ed29dcb72d 100644 --- a/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols +++ b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols @@ -1,36 +1,35 @@ === tests/cases/conformance/salsa/a.js === - export class C1 { } >C1 : Symbol(C1, Decl(a.js, 0, 0)) C1.staticProp = 0; ->C1.staticProp : Symbol(C1.staticProp, Decl(a.js, 1, 19)) +>C1.staticProp : Symbol(C1.staticProp, Decl(a.js, 0, 19)) >C1 : Symbol(C1, Decl(a.js, 0, 0)) ->staticProp : Symbol(C1.staticProp, Decl(a.js, 1, 19)) +>staticProp : Symbol(C1.staticProp, Decl(a.js, 0, 19)) export function F1() { } ->F1 : Symbol(F1, Decl(a.js, 2, 18)) +>F1 : Symbol(F1, Decl(a.js, 1, 18)) F1.staticProp = 0; ->F1.staticProp : Symbol(F1.staticProp, Decl(a.js, 4, 24)) ->F1 : Symbol(F1, Decl(a.js, 2, 18)) ->staticProp : Symbol(F1.staticProp, Decl(a.js, 4, 24)) +>F1.staticProp : Symbol(F1.staticProp, Decl(a.js, 3, 24)) +>F1 : Symbol(F1, Decl(a.js, 1, 18)) +>staticProp : Symbol(F1.staticProp, Decl(a.js, 3, 24)) export var C2 = class { }; ->C2 : Symbol(C2, Decl(a.js, 7, 10)) +>C2 : Symbol(C2, Decl(a.js, 6, 10)) C2.staticProp = 0; ->C2.staticProp : Symbol(C2.staticProp, Decl(a.js, 7, 26)) ->C2 : Symbol(C2, Decl(a.js, 7, 10)) ->staticProp : Symbol(C2.staticProp, Decl(a.js, 7, 26)) +>C2.staticProp : Symbol(C2.staticProp, Decl(a.js, 6, 26)) +>C2 : Symbol(C2, Decl(a.js, 6, 10)) +>staticProp : Symbol(C2.staticProp, Decl(a.js, 6, 26)) export let F2 = function () { }; ->F2 : Symbol(F2, Decl(a.js, 10, 10)) +>F2 : Symbol(F2, Decl(a.js, 9, 10)) F2.staticProp = 0; ->F2.staticProp : Symbol(F2.staticProp, Decl(a.js, 10, 32)) ->F2 : Symbol(F2, Decl(a.js, 10, 10)) ->staticProp : Symbol(F2.staticProp, Decl(a.js, 10, 32)) +>F2.staticProp : Symbol(F2.staticProp, Decl(a.js, 9, 32)) +>F2 : Symbol(F2, Decl(a.js, 9, 10)) +>staticProp : Symbol(F2.staticProp, Decl(a.js, 9, 32)) === tests/cases/conformance/salsa/global.js === class C3 { } @@ -74,35 +73,35 @@ var n: number; var n = a.C1.staticProp; >n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) ->a.C1.staticProp : Symbol(a.C1.staticProp, Decl(a.js, 1, 19)) +>a.C1.staticProp : Symbol(a.C1.staticProp, Decl(a.js, 0, 19)) >a.C1 : Symbol(a.C1, Decl(a.js, 0, 0)) >a : Symbol(a, Decl(b.ts, 0, 6)) >C1 : Symbol(a.C1, Decl(a.js, 0, 0)) ->staticProp : Symbol(a.C1.staticProp, Decl(a.js, 1, 19)) +>staticProp : Symbol(a.C1.staticProp, Decl(a.js, 0, 19)) var n = a.C2.staticProp; >n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) ->a.C2.staticProp : Symbol(C2.staticProp, Decl(a.js, 7, 26)) ->a.C2 : Symbol(a.C2, Decl(a.js, 7, 10)) +>a.C2.staticProp : Symbol(C2.staticProp, Decl(a.js, 6, 26)) +>a.C2 : Symbol(a.C2, Decl(a.js, 6, 10)) >a : Symbol(a, Decl(b.ts, 0, 6)) ->C2 : Symbol(a.C2, Decl(a.js, 7, 10)) ->staticProp : Symbol(C2.staticProp, Decl(a.js, 7, 26)) +>C2 : Symbol(a.C2, Decl(a.js, 6, 10)) +>staticProp : Symbol(C2.staticProp, Decl(a.js, 6, 26)) var n = a.F1.staticProp; >n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) ->a.F1.staticProp : Symbol(a.F1.staticProp, Decl(a.js, 4, 24)) ->a.F1 : Symbol(a.F1, Decl(a.js, 2, 18)) +>a.F1.staticProp : Symbol(a.F1.staticProp, Decl(a.js, 3, 24)) +>a.F1 : Symbol(a.F1, Decl(a.js, 1, 18)) >a : Symbol(a, Decl(b.ts, 0, 6)) ->F1 : Symbol(a.F1, Decl(a.js, 2, 18)) ->staticProp : Symbol(a.F1.staticProp, Decl(a.js, 4, 24)) +>F1 : Symbol(a.F1, Decl(a.js, 1, 18)) +>staticProp : Symbol(a.F1.staticProp, Decl(a.js, 3, 24)) var n = a.F2.staticProp; >n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3)) ->a.F2.staticProp : Symbol(F2.staticProp, Decl(a.js, 10, 32)) ->a.F2 : Symbol(a.F2, Decl(a.js, 10, 10)) +>a.F2.staticProp : Symbol(F2.staticProp, Decl(a.js, 9, 32)) +>a.F2 : Symbol(a.F2, Decl(a.js, 9, 10)) >a : Symbol(a, Decl(b.ts, 0, 6)) ->F2 : Symbol(a.F2, Decl(a.js, 10, 10)) ->staticProp : Symbol(F2.staticProp, Decl(a.js, 10, 32)) +>F2 : Symbol(a.F2, Decl(a.js, 9, 10)) +>staticProp : Symbol(F2.staticProp, Decl(a.js, 9, 32)) var n = C3.staticProp; diff --git a/tests/baselines/reference/inferringClassStaticMembersFromAssignments.types b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.types index d5a70d1fd80..69dff49724b 100644 --- a/tests/baselines/reference/inferringClassStaticMembersFromAssignments.types +++ b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.types @@ -1,5 +1,4 @@ === tests/cases/conformance/salsa/a.js === - export class C1 { } >C1 : C1